blob: 83a68983aa26ab26755d8ca70b4d7e850e194c1b [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>
Olga Kornievskaia68e76ad2008-12-23 16:17:15 -050041#include <linux/sunrpc/svcauth_gss.h>
Jeff Layton363168b2009-08-14 12:57:56 -040042#include <linux/sunrpc/clnt.h>
Boaz Harrosh9a74af22009-12-03 20:30:56 +020043#include "xdr4.h"
J. Bruce Fields0a3adad2009-11-04 18:12:35 -050044#include "vfs.h"
J. Bruce Fieldsbfa4b362012-04-25 16:49:18 -040045#include "current_stateid.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070046
47#define NFSDDBG_FACILITY NFSDDBG_PROC
48
49/* Globals */
J. Bruce Fieldscf07d2e2010-02-28 23:20:19 -050050time_t nfsd4_lease = 90; /* default lease time */
J. Bruce Fieldsefc4bb4f2010-03-02 11:04:06 -050051time_t nfsd4_grace = 90;
NeilBrownfd39ca92005-06-23 22:04:03 -070052static time_t boot_time;
J. Bruce Fieldsf32f3c22011-12-12 15:00:35 -050053
54#define all_ones {{~0,~0},~0}
55static const stateid_t one_stateid = {
56 .si_generation = ~0,
57 .si_opaque = all_ones,
58};
59static const stateid_t zero_stateid = {
60 /* all fields zero */
61};
Tigran Mkrtchyan19ff0f22012-02-13 22:55:23 +010062static const stateid_t currentstateid = {
63 .si_generation = 1,
64};
J. Bruce Fieldsf32f3c22011-12-12 15:00:35 -050065
Andy Adamsonec6b5d72009-04-03 08:28:28 +030066static u64 current_sessionid = 1;
NeilBrownfd39ca92005-06-23 22:04:03 -070067
J. Bruce Fieldsf32f3c22011-12-12 15:00:35 -050068#define ZERO_STATEID(stateid) (!memcmp((stateid), &zero_stateid, sizeof(stateid_t)))
69#define ONE_STATEID(stateid) (!memcmp((stateid), &one_stateid, sizeof(stateid_t)))
Tigran Mkrtchyan19ff0f22012-02-13 22:55:23 +010070#define CURRENT_STATEID(stateid) (!memcmp((stateid), &currentstateid, sizeof(stateid_t)))
Linus Torvalds1da177e2005-04-16 15:20:36 -070071
Linus Torvalds1da177e2005-04-16 15:20:36 -070072/* forward declarations */
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -040073static int check_for_locks(struct nfs4_file *filp, struct nfs4_lockowner *lowner);
Linus Torvalds1da177e2005-04-16 15:20:36 -070074
J. Bruce Fields8b671b82009-02-22 14:51:34 -080075/* Locking: */
76
77/* Currently used for almost all code touching nfsv4 state: */
Ingo Molnar353ab6e2006-03-26 01:37:12 -080078static DEFINE_MUTEX(client_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070079
J. Bruce Fields8b671b82009-02-22 14:51:34 -080080/*
81 * Currently used for the del_recall_lru and file hash table. In an
82 * effort to decrease the scope of the client_mutex, this spinlock may
83 * eventually cover more:
84 */
85static DEFINE_SPINLOCK(recall_lock);
86
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -040087static struct kmem_cache *openowner_slab = NULL;
88static struct kmem_cache *lockowner_slab = NULL;
Christoph Lametere18b8902006-12-06 20:33:20 -080089static struct kmem_cache *file_slab = NULL;
90static struct kmem_cache *stateid_slab = NULL;
91static struct kmem_cache *deleg_slab = NULL;
NeilBrowne60d4392005-06-23 22:03:01 -070092
Linus Torvalds1da177e2005-04-16 15:20:36 -070093void
94nfs4_lock_state(void)
95{
Ingo Molnar353ab6e2006-03-26 01:37:12 -080096 mutex_lock(&client_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070097}
98
Benny Halevy508dc6e2012-02-23 17:40:52 -080099static void free_session(struct kref *);
100
101/* Must be called under the client_lock */
102static void nfsd4_put_session_locked(struct nfsd4_session *ses)
103{
104 kref_put(&ses->se_ref, free_session);
105}
106
107static void nfsd4_get_session(struct nfsd4_session *ses)
108{
109 kref_get(&ses->se_ref);
110}
111
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112void
113nfs4_unlock_state(void)
114{
Ingo Molnar353ab6e2006-03-26 01:37:12 -0800115 mutex_unlock(&client_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116}
117
118static inline u32
119opaque_hashval(const void *ptr, int nbytes)
120{
121 unsigned char *cptr = (unsigned char *) ptr;
122
123 u32 x = 0;
124 while (nbytes--) {
125 x *= 37;
126 x += *cptr++;
127 }
128 return x;
129}
130
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131static struct list_head del_recall_lru;
132
J. Bruce Fields32513b42011-10-13 16:00:16 -0400133static void nfsd4_free_file(struct nfs4_file *f)
134{
135 kmem_cache_free(file_slab, f);
136}
137
NeilBrown13cd2182005-06-23 22:03:10 -0700138static inline void
139put_nfs4_file(struct nfs4_file *fi)
140{
J. Bruce Fields8b671b82009-02-22 14:51:34 -0800141 if (atomic_dec_and_lock(&fi->fi_ref, &recall_lock)) {
142 list_del(&fi->fi_hash);
143 spin_unlock(&recall_lock);
144 iput(fi->fi_inode);
J. Bruce Fields32513b42011-10-13 16:00:16 -0400145 nfsd4_free_file(fi);
J. Bruce Fields8b671b82009-02-22 14:51:34 -0800146 }
NeilBrown13cd2182005-06-23 22:03:10 -0700147}
148
149static inline void
150get_nfs4_file(struct nfs4_file *fi)
151{
J. Bruce Fields8b671b82009-02-22 14:51:34 -0800152 atomic_inc(&fi->fi_ref);
NeilBrown13cd2182005-06-23 22:03:10 -0700153}
154
NeilBrownef0f3392006-04-10 22:55:41 -0700155static int num_delegations;
Meelap Shahc2f1a552007-07-17 04:04:39 -0700156unsigned int max_delegations;
NeilBrownef0f3392006-04-10 22:55:41 -0700157
158/*
159 * Open owner state (share locks)
160 */
161
J. Bruce Fields16bfdaaf2011-11-07 17:23:30 -0500162/* hash tables for lock and open owners */
163#define OWNER_HASH_BITS 8
164#define OWNER_HASH_SIZE (1 << OWNER_HASH_BITS)
165#define OWNER_HASH_MASK (OWNER_HASH_SIZE - 1)
NeilBrownef0f3392006-04-10 22:55:41 -0700166
J. Bruce Fields16bfdaaf2011-11-07 17:23:30 -0500167static unsigned int ownerstr_hashval(u32 clientid, struct xdr_netobj *ownername)
J. Bruce Fieldsddc04c42011-07-30 23:46:29 -0400168{
169 unsigned int ret;
170
171 ret = opaque_hashval(ownername->data, ownername->len);
172 ret += clientid;
J. Bruce Fields16bfdaaf2011-11-07 17:23:30 -0500173 return ret & OWNER_HASH_MASK;
J. Bruce Fieldsddc04c42011-07-30 23:46:29 -0400174}
NeilBrownef0f3392006-04-10 22:55:41 -0700175
J. Bruce Fields16bfdaaf2011-11-07 17:23:30 -0500176static struct list_head ownerstr_hashtbl[OWNER_HASH_SIZE];
NeilBrownef0f3392006-04-10 22:55:41 -0700177
178/* hash table for nfs4_file */
179#define FILE_HASH_BITS 8
180#define FILE_HASH_SIZE (1 << FILE_HASH_BITS)
Shan Wei35079582011-01-14 17:35:59 +0800181
J. Bruce Fieldsddc04c42011-07-30 23:46:29 -0400182static unsigned int file_hashval(struct inode *ino)
183{
184 /* XXX: why are we hashing on inode pointer, anyway? */
185 return hash_ptr(ino, FILE_HASH_BITS);
186}
187
NeilBrownef0f3392006-04-10 22:55:41 -0700188static struct list_head file_hashtbl[FILE_HASH_SIZE];
NeilBrownef0f3392006-04-10 22:55:41 -0700189
J. Bruce Fields998db522010-08-07 09:21:41 -0400190static void __nfs4_file_get_access(struct nfs4_file *fp, int oflag)
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400191{
192 BUG_ON(!(fp->fi_fds[oflag] || fp->fi_fds[O_RDWR]));
193 atomic_inc(&fp->fi_access[oflag]);
194}
195
J. Bruce Fields998db522010-08-07 09:21:41 -0400196static void nfs4_file_get_access(struct nfs4_file *fp, int oflag)
197{
198 if (oflag == O_RDWR) {
199 __nfs4_file_get_access(fp, O_RDONLY);
200 __nfs4_file_get_access(fp, O_WRONLY);
201 } else
202 __nfs4_file_get_access(fp, oflag);
203}
204
205static void nfs4_file_put_fd(struct nfs4_file *fp, int oflag)
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400206{
207 if (fp->fi_fds[oflag]) {
208 fput(fp->fi_fds[oflag]);
209 fp->fi_fds[oflag] = NULL;
210 }
211}
212
J. Bruce Fields998db522010-08-07 09:21:41 -0400213static void __nfs4_file_put_access(struct nfs4_file *fp, int oflag)
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400214{
215 if (atomic_dec_and_test(&fp->fi_access[oflag])) {
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400216 nfs4_file_put_fd(fp, oflag);
J. Bruce Fields3d02fa22011-09-19 15:07:41 -0400217 /*
218 * It's also safe to get rid of the RDWR open *if*
219 * we no longer have need of the other kind of access
220 * or if we already have the other kind of open:
221 */
222 if (fp->fi_fds[1-oflag]
223 || atomic_read(&fp->fi_access[1 - oflag]) == 0)
224 nfs4_file_put_fd(fp, O_RDWR);
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400225 }
226}
227
J. Bruce Fields998db522010-08-07 09:21:41 -0400228static void nfs4_file_put_access(struct nfs4_file *fp, int oflag)
229{
230 if (oflag == O_RDWR) {
231 __nfs4_file_put_access(fp, O_RDONLY);
232 __nfs4_file_put_access(fp, O_WRONLY);
233 } else
234 __nfs4_file_put_access(fp, oflag);
235}
236
J. Bruce Fields6136d2b2011-09-23 16:21:15 -0400237static inline int get_new_stid(struct nfs4_stid *stid)
J. Bruce Fields36d44c62011-09-08 12:16:03 -0400238{
J. Bruce Fields6136d2b2011-09-23 16:21:15 -0400239 static int min_stateid = 0;
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -0400240 struct idr *stateids = &stid->sc_client->cl_stateids;
J. Bruce Fields6136d2b2011-09-23 16:21:15 -0400241 int new_stid;
242 int error;
J. Bruce Fields36d44c62011-09-08 12:16:03 -0400243
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -0400244 error = idr_get_new_above(stateids, stid, min_stateid, &new_stid);
J. Bruce Fields6136d2b2011-09-23 16:21:15 -0400245 /*
J. Bruce Fields996e0932011-10-17 11:14:48 -0400246 * Note: the necessary preallocation was done in
247 * nfs4_alloc_stateid(). The idr code caps the number of
248 * preallocations that can exist at a time, but the state lock
249 * prevents anyone from using ours before we get here:
J. Bruce Fields6136d2b2011-09-23 16:21:15 -0400250 */
251 BUG_ON(error);
252 /*
253 * It shouldn't be a problem to reuse an opaque stateid value.
254 * I don't think it is for 4.1. But with 4.0 I worry that, for
255 * example, a stray write retransmission could be accepted by
256 * the server when it should have been rejected. Therefore,
257 * adopt a trick from the sctp code to attempt to maximize the
258 * amount of time until an id is reused, by ensuring they always
259 * "increase" (mod INT_MAX):
260 */
261
262 min_stateid = new_stid+1;
263 if (min_stateid == INT_MAX)
264 min_stateid = 0;
265 return new_stid;
J. Bruce Fields36d44c62011-09-08 12:16:03 -0400266}
267
J. Bruce Fields996e0932011-10-17 11:14:48 -0400268static void init_stid(struct nfs4_stid *stid, struct nfs4_client *cl, unsigned char type)
J. Bruce Fields2a74aba2011-09-23 17:20:02 -0400269{
270 stateid_t *s = &stid->sc_stateid;
J. Bruce Fields6136d2b2011-09-23 16:21:15 -0400271 int new_id;
J. Bruce Fields2a74aba2011-09-23 17:20:02 -0400272
273 stid->sc_type = type;
274 stid->sc_client = cl;
275 s->si_opaque.so_clid = cl->cl_clientid;
J. Bruce Fields6136d2b2011-09-23 16:21:15 -0400276 new_id = get_new_stid(stid);
J. Bruce Fields6136d2b2011-09-23 16:21:15 -0400277 s->si_opaque.so_id = (u32)new_id;
J. Bruce Fields2a74aba2011-09-23 17:20:02 -0400278 /* Will be incremented before return to client: */
279 s->si_generation = 0;
J. Bruce Fields996e0932011-10-17 11:14:48 -0400280}
281
282static struct nfs4_stid *nfs4_alloc_stid(struct nfs4_client *cl, struct kmem_cache *slab)
283{
284 struct idr *stateids = &cl->cl_stateids;
285
286 if (!idr_pre_get(stateids, GFP_KERNEL))
287 return NULL;
288 /*
289 * Note: if we fail here (or any time between now and the time
290 * we actually get the new idr), we won't need to undo the idr
291 * preallocation, since the idr code caps the number of
292 * preallocated entries.
293 */
294 return kmem_cache_alloc(slab, GFP_KERNEL);
J. Bruce Fields2a74aba2011-09-23 17:20:02 -0400295}
296
J. Bruce Fields4cdc9512011-10-17 15:57:47 -0400297static struct nfs4_ol_stateid * nfs4_alloc_stateid(struct nfs4_client *clp)
298{
299 return openlockstateid(nfs4_alloc_stid(clp, stateid_slab));
300}
301
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302static struct nfs4_delegation *
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -0400303alloc_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 -0700304{
305 struct nfs4_delegation *dp;
306 struct nfs4_file *fp = stp->st_file;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307
308 dprintk("NFSD alloc_init_deleg\n");
J. Bruce Fieldsc3e48082010-07-28 10:08:57 -0400309 /*
310 * Major work on the lease subsystem (for example, to support
311 * calbacks on stat) will be required before we can support
312 * write delegations properly.
313 */
314 if (type != NFS4_OPEN_DELEGATE_READ)
315 return NULL;
Meelap Shah47f99402007-07-17 04:04:40 -0700316 if (fp->fi_had_conflict)
317 return NULL;
Meelap Shahc2f1a552007-07-17 04:04:39 -0700318 if (num_delegations > max_delegations)
NeilBrownef0f3392006-04-10 22:55:41 -0700319 return NULL;
J. Bruce Fields996e0932011-10-17 11:14:48 -0400320 dp = delegstateid(nfs4_alloc_stid(clp, deleg_slab));
NeilBrown5b2d21c2005-06-23 22:03:04 -0700321 if (dp == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322 return dp;
J. Bruce Fields996e0932011-10-17 11:14:48 -0400323 init_stid(&dp->dl_stid, clp, NFS4_DELEG_STID);
J. Bruce Fields2a74aba2011-09-23 17:20:02 -0400324 /*
325 * delegation seqid's are never incremented. The 4.1 special
J. Bruce Fields6136d2b2011-09-23 16:21:15 -0400326 * meaning of seqid 0 isn't meaningful, really, but let's avoid
327 * 0 anyway just for consistency and use 1:
J. Bruce Fields2a74aba2011-09-23 17:20:02 -0400328 */
329 dp->dl_stid.sc_stateid.si_generation = 1;
NeilBrownef0f3392006-04-10 22:55:41 -0700330 num_delegations++;
NeilBrownea1da632005-06-23 22:04:17 -0700331 INIT_LIST_HEAD(&dp->dl_perfile);
332 INIT_LIST_HEAD(&dp->dl_perclnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700333 INIT_LIST_HEAD(&dp->dl_recall_lru);
NeilBrown13cd2182005-06-23 22:03:10 -0700334 get_nfs4_file(fp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335 dp->dl_file = fp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336 dp->dl_type = type;
J. Bruce Fields6c02eaa2009-02-02 17:30:51 -0500337 fh_copy_shallow(&dp->dl_fh, &current_fh->fh_handle);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338 dp->dl_time = 0;
339 atomic_set(&dp->dl_count, 1);
J. Bruce Fieldsb5a1a812010-03-03 14:52:55 -0500340 INIT_WORK(&dp->dl_recall.cb_work, nfsd4_do_callback_rpc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341 return dp;
342}
343
344void
345nfs4_put_delegation(struct nfs4_delegation *dp)
346{
347 if (atomic_dec_and_test(&dp->dl_count)) {
348 dprintk("NFSD: freeing dp %p\n",dp);
NeilBrown13cd2182005-06-23 22:03:10 -0700349 put_nfs4_file(dp->dl_file);
NeilBrown5b2d21c2005-06-23 22:03:04 -0700350 kmem_cache_free(deleg_slab, dp);
NeilBrownef0f3392006-04-10 22:55:41 -0700351 num_delegations--;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352 }
353}
354
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -0500355static void nfs4_put_deleg_lease(struct nfs4_file *fp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356{
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -0500357 if (atomic_dec_and_test(&fp->fi_delegees)) {
358 vfs_setlease(fp->fi_deleg_file, F_UNLCK, &fp->fi_lease);
359 fp->fi_lease = NULL;
J. Bruce Fields4ee63622011-04-15 18:08:26 -0400360 fput(fp->fi_deleg_file);
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -0500361 fp->fi_deleg_file = NULL;
362 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363}
364
J. Bruce Fields6136d2b2011-09-23 16:21:15 -0400365static void unhash_stid(struct nfs4_stid *s)
366{
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -0400367 struct idr *stateids = &s->sc_client->cl_stateids;
368
369 idr_remove(stateids, s->sc_stateid.si_opaque.so_id);
J. Bruce Fields6136d2b2011-09-23 16:21:15 -0400370}
371
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372/* Called under the state lock. */
373static void
374unhash_delegation(struct nfs4_delegation *dp)
375{
J. Bruce Fields6136d2b2011-09-23 16:21:15 -0400376 unhash_stid(&dp->dl_stid);
NeilBrownea1da632005-06-23 22:04:17 -0700377 list_del_init(&dp->dl_perclnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378 spin_lock(&recall_lock);
J. Bruce Fields5d926e82011-02-07 16:53:46 -0500379 list_del_init(&dp->dl_perfile);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380 list_del_init(&dp->dl_recall_lru);
381 spin_unlock(&recall_lock);
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -0500382 nfs4_put_deleg_lease(dp->dl_file);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383 nfs4_put_delegation(dp);
384}
385
386/*
387 * SETCLIENTID state
388 */
389
Benny Halevy36acb662010-05-12 00:13:04 +0300390/* client_lock protects the client lru list and session hash table */
Benny Halevy9089f1b2010-05-12 00:12:26 +0300391static DEFINE_SPINLOCK(client_lock);
392
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393/* Hash tables for nfs4_clientid state */
394#define CLIENT_HASH_BITS 4
395#define CLIENT_HASH_SIZE (1 << CLIENT_HASH_BITS)
396#define CLIENT_HASH_MASK (CLIENT_HASH_SIZE - 1)
397
J. Bruce Fieldsddc04c42011-07-30 23:46:29 -0400398static unsigned int clientid_hashval(u32 id)
399{
400 return id & CLIENT_HASH_MASK;
401}
402
403static unsigned int clientstr_hashval(const char *name)
404{
405 return opaque_hashval(name, 8) & CLIENT_HASH_MASK;
406}
407
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408/*
409 * reclaim_str_hashtbl[] holds known client info from previous reset/reboot
410 * used in reboot/reset lease grace period processing
411 *
412 * conf_id_hashtbl[], and conf_str_hashtbl[] hold confirmed
413 * setclientid_confirmed info.
414 *
415 * unconf_str_hastbl[] and unconf_id_hashtbl[] hold unconfirmed
416 * setclientid info.
417 *
418 * client_lru holds client queue ordered by nfs4_client.cl_time
419 * for lease renewal.
420 *
421 * close_lru holds (open) stateowner queue ordered by nfs4_stateowner.so_time
422 * for last close replay.
423 */
424static struct list_head reclaim_str_hashtbl[CLIENT_HASH_SIZE];
425static int reclaim_str_hashtbl_size = 0;
426static struct list_head conf_id_hashtbl[CLIENT_HASH_SIZE];
427static struct list_head conf_str_hashtbl[CLIENT_HASH_SIZE];
428static struct list_head unconf_str_hashtbl[CLIENT_HASH_SIZE];
429static struct list_head unconf_id_hashtbl[CLIENT_HASH_SIZE];
430static struct list_head client_lru;
431static struct list_head close_lru;
432
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400433/*
434 * We store the NONE, READ, WRITE, and BOTH bits separately in the
435 * st_{access,deny}_bmap field of the stateid, in order to track not
436 * only what share bits are currently in force, but also what
437 * combinations of share bits previous opens have used. This allows us
438 * to enforce the recommendation of rfc 3530 14.2.19 that the server
439 * return an error if the client attempt to downgrade to a combination
440 * of share bits not explicable by closing some of its previous opens.
441 *
442 * XXX: This enforcement is actually incomplete, since we don't keep
443 * track of access/deny bit combinations; so, e.g., we allow:
444 *
445 * OPEN allow read, deny write
446 * OPEN allow both, deny none
447 * DOWNGRADE allow read, deny none
448 *
449 * which we should reject.
450 */
Jeff Layton5ae037e2012-05-11 09:45:11 -0400451static unsigned int
452bmap_to_share_mode(unsigned long bmap) {
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400453 int i;
Jeff Layton5ae037e2012-05-11 09:45:11 -0400454 unsigned int access = 0;
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400455
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400456 for (i = 1; i < 4; i++) {
457 if (test_bit(i, &bmap))
Jeff Layton5ae037e2012-05-11 09:45:11 -0400458 access |= i;
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400459 }
Jeff Layton5ae037e2012-05-11 09:45:11 -0400460 return access;
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400461}
462
Jeff Layton3a328612012-05-11 09:45:12 -0400463static bool
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -0400464test_share(struct nfs4_ol_stateid *stp, struct nfsd4_open *open) {
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400465 unsigned int access, deny;
466
Jeff Layton5ae037e2012-05-11 09:45:11 -0400467 access = bmap_to_share_mode(stp->st_access_bmap);
468 deny = bmap_to_share_mode(stp->st_deny_bmap);
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400469 if ((access & open->op_share_deny) || (deny & open->op_share_access))
Jeff Layton3a328612012-05-11 09:45:12 -0400470 return false;
471 return true;
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400472}
473
Jeff Layton82c5ff12012-05-11 09:45:13 -0400474/* set share access for a given stateid */
475static inline void
476set_access(u32 access, struct nfs4_ol_stateid *stp)
477{
478 __set_bit(access, &stp->st_access_bmap);
479}
480
481/* clear share access for a given stateid */
482static inline void
483clear_access(u32 access, struct nfs4_ol_stateid *stp)
484{
485 __clear_bit(access, &stp->st_access_bmap);
486}
487
488/* test whether a given stateid has access */
489static inline bool
490test_access(u32 access, struct nfs4_ol_stateid *stp)
491{
492 return test_bit(access, &stp->st_access_bmap);
493}
494
Jeff Laytonce0fc432012-05-11 09:45:14 -0400495/* set share deny for a given stateid */
496static inline void
497set_deny(u32 access, struct nfs4_ol_stateid *stp)
498{
499 __set_bit(access, &stp->st_deny_bmap);
500}
501
502/* clear share deny for a given stateid */
503static inline void
504clear_deny(u32 access, struct nfs4_ol_stateid *stp)
505{
506 __clear_bit(access, &stp->st_deny_bmap);
507}
508
509/* test whether a given stateid is denying specific access */
510static inline bool
511test_deny(u32 access, struct nfs4_ol_stateid *stp)
512{
513 return test_bit(access, &stp->st_deny_bmap);
514}
515
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400516static int nfs4_access_to_omode(u32 access)
517{
J. Bruce Fields8f34a432010-09-02 15:23:16 -0400518 switch (access & NFS4_SHARE_ACCESS_BOTH) {
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400519 case NFS4_SHARE_ACCESS_READ:
520 return O_RDONLY;
521 case NFS4_SHARE_ACCESS_WRITE:
522 return O_WRONLY;
523 case NFS4_SHARE_ACCESS_BOTH:
524 return O_RDWR;
525 }
526 BUG();
527}
528
Jeff Layton82c5ff12012-05-11 09:45:13 -0400529/* release all access and file references for a given stateid */
530static void
531release_all_access(struct nfs4_ol_stateid *stp)
532{
533 int i;
534
535 for (i = 1; i < 4; i++) {
536 if (test_access(i, stp))
537 nfs4_file_put_access(stp->st_file,
538 nfs4_access_to_omode(i));
539 clear_access(i, stp);
540 }
541}
542
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -0400543static void unhash_generic_stateid(struct nfs4_ol_stateid *stp)
J. Bruce Fields529d7b22011-03-02 23:48:33 -0500544{
J. Bruce Fields529d7b22011-03-02 23:48:33 -0500545 list_del(&stp->st_perfile);
546 list_del(&stp->st_perstateowner);
547}
548
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -0400549static void close_generic_stateid(struct nfs4_ol_stateid *stp)
J. Bruce Fields529d7b22011-03-02 23:48:33 -0500550{
Jeff Layton82c5ff12012-05-11 09:45:13 -0400551 release_all_access(stp);
OGAWA Hirofumia96e5b92011-04-18 11:48:55 -0400552 put_nfs4_file(stp->st_file);
J. Bruce Fields4665e2b2011-09-06 14:50:49 -0400553 stp->st_file = NULL;
554}
555
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -0400556static void free_generic_stateid(struct nfs4_ol_stateid *stp)
J. Bruce Fields4665e2b2011-09-06 14:50:49 -0400557{
J. Bruce Fields529d7b22011-03-02 23:48:33 -0500558 kmem_cache_free(stateid_slab, stp);
559}
560
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -0400561static void release_lock_stateid(struct nfs4_ol_stateid *stp)
J. Bruce Fields529d7b22011-03-02 23:48:33 -0500562{
563 struct file *file;
564
565 unhash_generic_stateid(stp);
J. Bruce Fields6136d2b2011-09-23 16:21:15 -0400566 unhash_stid(&stp->st_stid);
J. Bruce Fields529d7b22011-03-02 23:48:33 -0500567 file = find_any_file(stp->st_file);
568 if (file)
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -0400569 locks_remove_posix(file, (fl_owner_t)lockowner(stp->st_stateowner));
J. Bruce Fields38c387b2011-09-16 17:42:48 -0400570 close_generic_stateid(stp);
J. Bruce Fields529d7b22011-03-02 23:48:33 -0500571 free_generic_stateid(stp);
572}
573
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -0400574static void unhash_lockowner(struct nfs4_lockowner *lo)
J. Bruce Fields529d7b22011-03-02 23:48:33 -0500575{
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -0400576 struct nfs4_ol_stateid *stp;
J. Bruce Fields529d7b22011-03-02 23:48:33 -0500577
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -0400578 list_del(&lo->lo_owner.so_strhash);
579 list_del(&lo->lo_perstateid);
J. Bruce Fields009673b2011-11-07 17:40:10 -0500580 list_del(&lo->lo_owner_ino_hash);
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -0400581 while (!list_empty(&lo->lo_owner.so_stateids)) {
582 stp = list_first_entry(&lo->lo_owner.so_stateids,
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -0400583 struct nfs4_ol_stateid, st_perstateowner);
J. Bruce Fields529d7b22011-03-02 23:48:33 -0500584 release_lock_stateid(stp);
585 }
586}
587
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -0400588static void release_lockowner(struct nfs4_lockowner *lo)
J. Bruce Fields529d7b22011-03-02 23:48:33 -0500589{
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -0400590 unhash_lockowner(lo);
591 nfs4_free_lockowner(lo);
J. Bruce Fields529d7b22011-03-02 23:48:33 -0500592}
593
594static void
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -0400595release_stateid_lockowners(struct nfs4_ol_stateid *open_stp)
J. Bruce Fields529d7b22011-03-02 23:48:33 -0500596{
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -0400597 struct nfs4_lockowner *lo;
J. Bruce Fields529d7b22011-03-02 23:48:33 -0500598
599 while (!list_empty(&open_stp->st_lockowners)) {
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -0400600 lo = list_entry(open_stp->st_lockowners.next,
601 struct nfs4_lockowner, lo_perstateid);
602 release_lockowner(lo);
J. Bruce Fields529d7b22011-03-02 23:48:33 -0500603 }
604}
605
J. Bruce Fields38c387b2011-09-16 17:42:48 -0400606static void unhash_open_stateid(struct nfs4_ol_stateid *stp)
J. Bruce Fields22839632009-01-11 14:27:17 -0500607{
608 unhash_generic_stateid(stp);
609 release_stateid_lockowners(stp);
J. Bruce Fields38c387b2011-09-16 17:42:48 -0400610 close_generic_stateid(stp);
611}
612
613static void release_open_stateid(struct nfs4_ol_stateid *stp)
614{
615 unhash_open_stateid(stp);
J. Bruce Fields6136d2b2011-09-23 16:21:15 -0400616 unhash_stid(&stp->st_stid);
J. Bruce Fields22839632009-01-11 14:27:17 -0500617 free_generic_stateid(stp);
618}
619
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -0400620static void unhash_openowner(struct nfs4_openowner *oo)
J. Bruce Fieldsf1d110c2009-01-11 14:37:31 -0500621{
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -0400622 struct nfs4_ol_stateid *stp;
J. Bruce Fieldsf1d110c2009-01-11 14:37:31 -0500623
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -0400624 list_del(&oo->oo_owner.so_strhash);
625 list_del(&oo->oo_perclient);
626 while (!list_empty(&oo->oo_owner.so_stateids)) {
627 stp = list_first_entry(&oo->oo_owner.so_stateids,
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -0400628 struct nfs4_ol_stateid, st_perstateowner);
J. Bruce Fieldsf044ff82009-01-11 15:24:04 -0500629 release_open_stateid(stp);
J. Bruce Fieldsf1d110c2009-01-11 14:37:31 -0500630 }
631}
632
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -0400633static void release_last_closed_stateid(struct nfs4_openowner *oo)
634{
635 struct nfs4_ol_stateid *s = oo->oo_last_closed_stid;
636
637 if (s) {
J. Bruce Fields6136d2b2011-09-23 16:21:15 -0400638 unhash_stid(&s->st_stid);
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -0400639 free_generic_stateid(s);
640 oo->oo_last_closed_stid = NULL;
641 }
642}
643
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -0400644static void release_openowner(struct nfs4_openowner *oo)
J. Bruce Fieldsf1d110c2009-01-11 14:37:31 -0500645{
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -0400646 unhash_openowner(oo);
647 list_del(&oo->oo_close_lru);
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -0400648 release_last_closed_stateid(oo);
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -0400649 nfs4_free_openowner(oo);
J. Bruce Fieldsf1d110c2009-01-11 14:37:31 -0500650}
651
Marc Eshel5282fd72009-04-03 08:27:52 +0300652#define SESSION_HASH_SIZE 512
653static struct list_head sessionid_hashtbl[SESSION_HASH_SIZE];
654
655static inline int
656hash_sessionid(struct nfs4_sessionid *sessionid)
657{
658 struct nfsd4_sessionid *sid = (struct nfsd4_sessionid *)sessionid;
659
660 return sid->sequence % SESSION_HASH_SIZE;
661}
662
Trond Myklebust8f199b82012-03-20 15:11:17 -0400663#ifdef NFSD_DEBUG
Marc Eshel5282fd72009-04-03 08:27:52 +0300664static inline void
665dump_sessionid(const char *fn, struct nfs4_sessionid *sessionid)
666{
667 u32 *ptr = (u32 *)(&sessionid->data[0]);
668 dprintk("%s: %u:%u:%u:%u\n", fn, ptr[0], ptr[1], ptr[2], ptr[3]);
669}
Trond Myklebust8f199b82012-03-20 15:11:17 -0400670#else
671static inline void
672dump_sessionid(const char *fn, struct nfs4_sessionid *sessionid)
673{
674}
675#endif
676
Marc Eshel5282fd72009-04-03 08:27:52 +0300677
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300678static void
679gen_sessionid(struct nfsd4_session *ses)
680{
681 struct nfs4_client *clp = ses->se_client;
682 struct nfsd4_sessionid *sid;
683
684 sid = (struct nfsd4_sessionid *)ses->se_sessionid.data;
685 sid->clientid = clp->cl_clientid;
686 sid->sequence = current_sessionid++;
687 sid->reserved = 0;
688}
689
690/*
Andy Adamsona649637c72009-08-28 08:45:01 -0400691 * The protocol defines ca_maxresponssize_cached to include the size of
692 * the rpc header, but all we need to cache is the data starting after
693 * the end of the initial SEQUENCE operation--the rest we regenerate
694 * each time. Therefore we can advertise a ca_maxresponssize_cached
695 * value that is the number of bytes in our cache plus a few additional
696 * bytes. In order to stay on the safe side, and not promise more than
697 * we can cache, those additional bytes must be the minimum possible: 24
698 * bytes of rpc header (xid through accept state, with AUTH_NULL
699 * verifier), 12 for the compound header (with zero-length tag), and 44
700 * for the SEQUENCE op response:
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300701 */
Andy Adamsona649637c72009-08-28 08:45:01 -0400702#define NFSD_MIN_HDR_SEQ_SZ (24 + 12 + 44)
703
Andy Adamson557ce262009-08-28 08:45:04 -0400704static void
705free_session_slots(struct nfsd4_session *ses)
706{
707 int i;
708
709 for (i = 0; i < ses->se_fchannel.maxreqs; i++)
710 kfree(ses->se_slots[i]);
711}
712
J. Bruce Fieldsefe0cb62009-10-24 20:52:16 -0400713/*
714 * We don't actually need to cache the rpc and session headers, so we
715 * can allocate a little less for each slot:
716 */
717static inline int slot_bytes(struct nfsd4_channel_attrs *ca)
718{
719 return ca->maxresp_cached - NFSD_MIN_HDR_SEQ_SZ;
720}
721
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400722static int nfsd4_sanitize_slot_size(u32 size)
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300723{
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400724 size -= NFSD_MIN_HDR_SEQ_SZ; /* We don't cache the rpc header */
725 size = min_t(u32, size, NFSD_SLOT_CACHE_SIZE);
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300726
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400727 return size;
728}
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300729
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400730/*
731 * XXX: If we run out of reserved DRC memory we could (up to a point)
732 * re-negotiate active sessions and reduce their slot usage to make
Justin P. Mattock42b2aa82011-11-28 20:31:00 -0800733 * room for new connections. For now we just fail the create session.
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400734 */
735static int nfsd4_get_drc_mem(int slotsize, u32 num)
736{
737 int avail;
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300738
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400739 num = min_t(u32, num, NFSD_MAX_SLOTS_PER_SESSION);
Andy Adamson557ce262009-08-28 08:45:04 -0400740
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400741 spin_lock(&nfsd_drc_lock);
742 avail = min_t(int, NFSD_MAX_MEM_PER_SESSION,
743 nfsd_drc_max_mem - nfsd_drc_mem_used);
744 num = min_t(int, num, avail / slotsize);
745 nfsd_drc_mem_used += num * slotsize;
746 spin_unlock(&nfsd_drc_lock);
747
748 return num;
749}
750
751static void nfsd4_put_drc_mem(int slotsize, int num)
752{
753 spin_lock(&nfsd_drc_lock);
754 nfsd_drc_mem_used -= slotsize * num;
755 spin_unlock(&nfsd_drc_lock);
756}
757
758static struct nfsd4_session *alloc_session(int slotsize, int numslots)
759{
760 struct nfsd4_session *new;
761 int mem, i;
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300762
J. Bruce Fieldsc23753d2010-09-27 16:22:30 -0400763 BUILD_BUG_ON(NFSD_MAX_SLOTS_PER_SESSION * sizeof(struct nfsd4_slot *)
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400764 + sizeof(struct nfsd4_session) > PAGE_SIZE);
765 mem = numslots * sizeof(struct nfsd4_slot *);
Andy Adamson557ce262009-08-28 08:45:04 -0400766
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400767 new = kzalloc(sizeof(*new) + mem, GFP_KERNEL);
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300768 if (!new)
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400769 return NULL;
Andy Adamson557ce262009-08-28 08:45:04 -0400770 /* allocate each struct nfsd4_slot and data cache in one piece */
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400771 for (i = 0; i < numslots; i++) {
772 mem = sizeof(struct nfsd4_slot) + slotsize;
773 new->se_slots[i] = kzalloc(mem, GFP_KERNEL);
774 if (!new->se_slots[i])
Andy Adamson557ce262009-08-28 08:45:04 -0400775 goto out_free;
Andy Adamson557ce262009-08-28 08:45:04 -0400776 }
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400777 return new;
778out_free:
779 while (i--)
780 kfree(new->se_slots[i]);
781 kfree(new);
782 return NULL;
783}
784
785static void init_forechannel_attrs(struct nfsd4_channel_attrs *new, struct nfsd4_channel_attrs *req, int numslots, int slotsize)
786{
787 u32 maxrpc = nfsd_serv->sv_max_mesg;
788
789 new->maxreqs = numslots;
Mi Jinlongd2b21742011-03-10 17:43:37 +0800790 new->maxresp_cached = min_t(u32, req->maxresp_cached,
791 slotsize + NFSD_MIN_HDR_SEQ_SZ);
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400792 new->maxreq_sz = min_t(u32, req->maxreq_sz, maxrpc);
793 new->maxresp_sz = min_t(u32, req->maxresp_sz, maxrpc);
794 new->maxops = min_t(u32, req->maxops, NFSD_MAX_OPS_PER_COMPOUND);
795}
796
J. Bruce Fields19cf5c02010-06-06 18:37:16 -0400797static void free_conn(struct nfsd4_conn *c)
798{
799 svc_xprt_put(c->cn_xprt);
800 kfree(c);
801}
802
803static void nfsd4_conn_lost(struct svc_xpt_user *u)
804{
805 struct nfsd4_conn *c = container_of(u, struct nfsd4_conn, cn_xpt_user);
806 struct nfs4_client *clp = c->cn_session->se_client;
807
808 spin_lock(&clp->cl_lock);
809 if (!list_empty(&c->cn_persession)) {
810 list_del(&c->cn_persession);
811 free_conn(c);
812 }
813 spin_unlock(&clp->cl_lock);
J. Bruce Fieldseea49802010-11-18 08:34:12 -0500814 nfsd4_probe_callback(clp);
J. Bruce Fields19cf5c02010-06-06 18:37:16 -0400815}
816
J. Bruce Fieldsd29c3742010-06-15 17:34:11 -0400817static struct nfsd4_conn *alloc_conn(struct svc_rqst *rqstp, u32 flags)
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400818{
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400819 struct nfsd4_conn *conn;
820
821 conn = kmalloc(sizeof(struct nfsd4_conn), GFP_KERNEL);
822 if (!conn)
J. Bruce Fieldsdb906812010-09-29 15:29:32 -0400823 return NULL;
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400824 svc_xprt_get(rqstp->rq_xprt);
825 conn->cn_xprt = rqstp->rq_xprt;
J. Bruce Fieldsd29c3742010-06-15 17:34:11 -0400826 conn->cn_flags = flags;
J. Bruce Fieldsdb906812010-09-29 15:29:32 -0400827 INIT_LIST_HEAD(&conn->cn_xpt_user.list);
828 return conn;
829}
830
J. Bruce Fields328ead22010-09-29 16:11:06 -0400831static void __nfsd4_hash_conn(struct nfsd4_conn *conn, struct nfsd4_session *ses)
832{
833 conn->cn_session = ses;
834 list_add(&conn->cn_persession, &ses->se_conns);
835}
836
J. Bruce Fieldsdb906812010-09-29 15:29:32 -0400837static void nfsd4_hash_conn(struct nfsd4_conn *conn, struct nfsd4_session *ses)
838{
839 struct nfs4_client *clp = ses->se_client;
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400840
841 spin_lock(&clp->cl_lock);
J. Bruce Fields328ead22010-09-29 16:11:06 -0400842 __nfsd4_hash_conn(conn, ses);
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400843 spin_unlock(&clp->cl_lock);
J. Bruce Fieldsdb906812010-09-29 15:29:32 -0400844}
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400845
J. Bruce Fields21b75b02010-10-26 10:07:17 -0400846static int nfsd4_register_conn(struct nfsd4_conn *conn)
J. Bruce Fieldsdb906812010-09-29 15:29:32 -0400847{
J. Bruce Fields19cf5c02010-06-06 18:37:16 -0400848 conn->cn_xpt_user.callback = nfsd4_conn_lost;
J. Bruce Fields21b75b02010-10-26 10:07:17 -0400849 return register_xpt_user(conn->cn_xprt, &conn->cn_xpt_user);
J. Bruce Fieldsdb906812010-09-29 15:29:32 -0400850}
851
J. Bruce Fields1d1bc8f2010-10-04 23:12:59 -0400852static __be32 nfsd4_new_conn(struct svc_rqst *rqstp, struct nfsd4_session *ses, u32 dir)
J. Bruce Fieldsdb906812010-09-29 15:29:32 -0400853{
854 struct nfsd4_conn *conn;
J. Bruce Fields21b75b02010-10-26 10:07:17 -0400855 int ret;
J. Bruce Fieldsdb906812010-09-29 15:29:32 -0400856
J. Bruce Fields1d1bc8f2010-10-04 23:12:59 -0400857 conn = alloc_conn(rqstp, dir);
J. Bruce Fieldsdb906812010-09-29 15:29:32 -0400858 if (!conn)
859 return nfserr_jukebox;
860 nfsd4_hash_conn(conn, ses);
J. Bruce Fields21b75b02010-10-26 10:07:17 -0400861 ret = nfsd4_register_conn(conn);
862 if (ret)
863 /* oops; xprt is already down: */
864 nfsd4_conn_lost(&conn->cn_xpt_user);
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400865 return nfs_ok;
866}
867
J. Bruce Fields1d1bc8f2010-10-04 23:12:59 -0400868static __be32 nfsd4_new_conn_from_crses(struct svc_rqst *rqstp, struct nfsd4_session *ses)
869{
870 u32 dir = NFS4_CDFC4_FORE;
871
872 if (ses->se_flags & SESSION4_BACK_CHAN)
873 dir |= NFS4_CDFC4_BACK;
874
875 return nfsd4_new_conn(rqstp, ses, dir);
876}
877
878/* must be called under client_lock */
J. Bruce Fields19cf5c02010-06-06 18:37:16 -0400879static void nfsd4_del_conns(struct nfsd4_session *s)
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400880{
J. Bruce Fields19cf5c02010-06-06 18:37:16 -0400881 struct nfs4_client *clp = s->se_client;
882 struct nfsd4_conn *c;
883
884 spin_lock(&clp->cl_lock);
885 while (!list_empty(&s->se_conns)) {
886 c = list_first_entry(&s->se_conns, struct nfsd4_conn, cn_persession);
887 list_del_init(&c->cn_persession);
888 spin_unlock(&clp->cl_lock);
889
890 unregister_xpt_user(c->cn_xprt, &c->cn_xpt_user);
891 free_conn(c);
892
893 spin_lock(&clp->cl_lock);
894 }
895 spin_unlock(&clp->cl_lock);
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400896}
897
Benny Halevy508dc6e2012-02-23 17:40:52 -0800898static void free_session(struct kref *kref)
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400899{
900 struct nfsd4_session *ses;
901 int mem;
902
Benny Halevy508dc6e2012-02-23 17:40:52 -0800903 BUG_ON(!spin_is_locked(&client_lock));
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400904 ses = container_of(kref, struct nfsd4_session, se_ref);
J. Bruce Fields19cf5c02010-06-06 18:37:16 -0400905 nfsd4_del_conns(ses);
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400906 spin_lock(&nfsd_drc_lock);
907 mem = ses->se_fchannel.maxreqs * slot_bytes(&ses->se_fchannel);
908 nfsd_drc_mem_used -= mem;
909 spin_unlock(&nfsd_drc_lock);
910 free_session_slots(ses);
911 kfree(ses);
912}
913
Benny Halevy508dc6e2012-02-23 17:40:52 -0800914void nfsd4_put_session(struct nfsd4_session *ses)
915{
916 spin_lock(&client_lock);
917 nfsd4_put_session_locked(ses);
918 spin_unlock(&client_lock);
919}
920
J. Bruce Fieldsac7c46f22010-06-14 19:01:57 -0400921static struct nfsd4_session *alloc_init_session(struct svc_rqst *rqstp, struct nfs4_client *clp, struct nfsd4_create_session *cses)
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400922{
923 struct nfsd4_session *new;
924 struct nfsd4_channel_attrs *fchan = &cses->fore_channel;
925 int numslots, slotsize;
J. Bruce Fields57b7b432012-04-25 17:58:50 -0400926 __be32 status;
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400927 int idx;
928
929 /*
930 * Note decreasing slot size below client's request may
931 * make it difficult for client to function correctly, whereas
932 * decreasing the number of slots will (just?) affect
933 * performance. When short on memory we therefore prefer to
934 * decrease number of slots instead of their size.
935 */
936 slotsize = nfsd4_sanitize_slot_size(fchan->maxresp_cached);
937 numslots = nfsd4_get_drc_mem(slotsize, fchan->maxreqs);
Mi Jinlongced6dfe2010-11-11 18:03:50 +0800938 if (numslots < 1)
939 return NULL;
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400940
941 new = alloc_session(slotsize, numslots);
942 if (!new) {
943 nfsd4_put_drc_mem(slotsize, fchan->maxreqs);
J. Bruce Fieldsac7c46f22010-06-14 19:01:57 -0400944 return NULL;
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400945 }
946 init_forechannel_attrs(&new->se_fchannel, fchan, numslots, slotsize);
Andy Adamson557ce262009-08-28 08:45:04 -0400947
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300948 new->se_client = clp;
949 gen_sessionid(new);
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300950
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400951 INIT_LIST_HEAD(&new->se_conns);
952
J. Bruce Fieldsac7c46f22010-06-14 19:01:57 -0400953 new->se_cb_seq_nr = 1;
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300954 new->se_flags = cses->flags;
J. Bruce Fields8b5ce5c2010-10-19 17:31:50 -0400955 new->se_cb_prog = cses->callback_prog;
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300956 kref_init(&new->se_ref);
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400957 idx = hash_sessionid(&new->se_sessionid);
Benny Halevy9089f1b2010-05-12 00:12:26 +0300958 spin_lock(&client_lock);
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300959 list_add(&new->se_hash, &sessionid_hashtbl[idx]);
J. Bruce Fields4c649372010-06-15 14:22:37 -0400960 spin_lock(&clp->cl_lock);
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300961 list_add(&new->se_perclnt, &clp->cl_sessions);
J. Bruce Fields4c649372010-06-15 14:22:37 -0400962 spin_unlock(&clp->cl_lock);
Benny Halevy9089f1b2010-05-12 00:12:26 +0300963 spin_unlock(&client_lock);
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300964
J. Bruce Fields1d1bc8f2010-10-04 23:12:59 -0400965 status = nfsd4_new_conn_from_crses(rqstp, new);
J. Bruce Fieldsac7c46f22010-06-14 19:01:57 -0400966 /* whoops: benny points out, status is ignored! (err, or bogus) */
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400967 if (status) {
Benny Halevy508dc6e2012-02-23 17:40:52 -0800968 spin_lock(&client_lock);
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400969 free_session(&new->se_ref);
Benny Halevy508dc6e2012-02-23 17:40:52 -0800970 spin_unlock(&client_lock);
J. Bruce Fieldsac7c46f22010-06-14 19:01:57 -0400971 return NULL;
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400972 }
J. Bruce Fieldsdcbeaa62010-06-15 17:25:45 -0400973 if (cses->flags & SESSION4_BACK_CHAN) {
J. Bruce Fieldsedd76782010-06-14 22:26:31 -0400974 struct sockaddr *sa = svc_addr(rqstp);
J. Bruce Fieldsdcbeaa62010-06-15 17:25:45 -0400975 /*
976 * This is a little silly; with sessions there's no real
977 * use for the callback address. Use the peer address
978 * as a reasonable default for now, but consider fixing
979 * the rpc client not to require an address in the
980 * future:
981 */
J. Bruce Fieldsedd76782010-06-14 22:26:31 -0400982 rpc_copy_addr((struct sockaddr *)&clp->cl_cb_conn.cb_addr, sa);
983 clp->cl_cb_conn.cb_addrlen = svc_addr_len(sa);
J. Bruce Fieldsedd76782010-06-14 22:26:31 -0400984 }
J. Bruce Fieldsdcbeaa62010-06-15 17:25:45 -0400985 nfsd4_probe_callback(clp);
J. Bruce Fieldsac7c46f22010-06-14 19:01:57 -0400986 return new;
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300987}
988
Benny Halevy9089f1b2010-05-12 00:12:26 +0300989/* caller must hold client_lock */
Marc Eshel5282fd72009-04-03 08:27:52 +0300990static struct nfsd4_session *
991find_in_sessionid_hashtbl(struct nfs4_sessionid *sessionid)
992{
993 struct nfsd4_session *elem;
994 int idx;
995
996 dump_sessionid(__func__, sessionid);
997 idx = hash_sessionid(sessionid);
Marc Eshel5282fd72009-04-03 08:27:52 +0300998 /* Search in the appropriate list */
999 list_for_each_entry(elem, &sessionid_hashtbl[idx], se_hash) {
Marc Eshel5282fd72009-04-03 08:27:52 +03001000 if (!memcmp(elem->se_sessionid.data, sessionid->data,
1001 NFS4_MAX_SESSIONID_LEN)) {
1002 return elem;
1003 }
1004 }
1005
1006 dprintk("%s: session not found\n", __func__);
1007 return NULL;
1008}
1009
Benny Halevy9089f1b2010-05-12 00:12:26 +03001010/* caller must hold client_lock */
Andy Adamson7116ed62009-04-03 08:27:43 +03001011static void
Marc Eshel5282fd72009-04-03 08:27:52 +03001012unhash_session(struct nfsd4_session *ses)
Andy Adamson7116ed62009-04-03 08:27:43 +03001013{
1014 list_del(&ses->se_hash);
J. Bruce Fields4c649372010-06-15 14:22:37 -04001015 spin_lock(&ses->se_client->cl_lock);
Andy Adamson7116ed62009-04-03 08:27:43 +03001016 list_del(&ses->se_perclnt);
J. Bruce Fields4c649372010-06-15 14:22:37 -04001017 spin_unlock(&ses->se_client->cl_lock);
Marc Eshel5282fd72009-04-03 08:27:52 +03001018}
1019
Benny Halevy36acb662010-05-12 00:13:04 +03001020/* must be called under the client_lock */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001021static inline void
Benny Halevy36acb662010-05-12 00:13:04 +03001022renew_client_locked(struct nfs4_client *clp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001023{
Benny Halevy07cd4902010-05-12 00:13:41 +03001024 if (is_client_expired(clp)) {
J. Bruce Fields74477582012-05-04 14:57:52 -04001025 WARN_ON(1);
1026 printk("%s: client (clientid %08x/%08x) already expired\n",
Benny Halevy07cd4902010-05-12 00:13:41 +03001027 __func__,
1028 clp->cl_clientid.cl_boot,
1029 clp->cl_clientid.cl_id);
1030 return;
1031 }
1032
Linus Torvalds1da177e2005-04-16 15:20:36 -07001033 dprintk("renewing client (clientid %08x/%08x)\n",
1034 clp->cl_clientid.cl_boot,
1035 clp->cl_clientid.cl_id);
1036 list_move_tail(&clp->cl_lru, &client_lru);
1037 clp->cl_time = get_seconds();
1038}
1039
Benny Halevy36acb662010-05-12 00:13:04 +03001040static inline void
1041renew_client(struct nfs4_client *clp)
1042{
1043 spin_lock(&client_lock);
1044 renew_client_locked(clp);
1045 spin_unlock(&client_lock);
1046}
1047
Linus Torvalds1da177e2005-04-16 15:20:36 -07001048/* SETCLIENTID and SETCLIENTID_CONFIRM Helper functions */
1049static int
1050STALE_CLIENTID(clientid_t *clid)
1051{
1052 if (clid->cl_boot == boot_time)
1053 return 0;
Andy Adamson60adfc52009-04-03 08:28:50 +03001054 dprintk("NFSD stale clientid (%08x/%08x) boot_time %08lx\n",
1055 clid->cl_boot, clid->cl_id, boot_time);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001056 return 1;
1057}
1058
1059/*
1060 * XXX Should we use a slab cache ?
1061 * This type of memory management is somewhat inefficient, but we use it
1062 * anyway since SETCLIENTID is not a common operation.
1063 */
J. Bruce Fields35bba9a2007-11-21 22:07:08 -05001064static struct nfs4_client *alloc_client(struct xdr_netobj name)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001065{
1066 struct nfs4_client *clp;
1067
J. Bruce Fields35bba9a2007-11-21 22:07:08 -05001068 clp = kzalloc(sizeof(struct nfs4_client), GFP_KERNEL);
1069 if (clp == NULL)
1070 return NULL;
Thomas Meyer67114fe2011-11-17 23:43:40 +01001071 clp->cl_name.data = kmemdup(name.data, name.len, GFP_KERNEL);
J. Bruce Fields35bba9a2007-11-21 22:07:08 -05001072 if (clp->cl_name.data == NULL) {
1073 kfree(clp);
1074 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001075 }
J. Bruce Fields35bba9a2007-11-21 22:07:08 -05001076 clp->cl_name.len = name.len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001077 return clp;
1078}
1079
1080static inline void
1081free_client(struct nfs4_client *clp)
1082{
Benny Halevy508dc6e2012-02-23 17:40:52 -08001083 BUG_ON(!spin_is_locked(&client_lock));
J. Bruce Fields792c95d2010-10-12 19:55:25 -04001084 while (!list_empty(&clp->cl_sessions)) {
1085 struct nfsd4_session *ses;
1086 ses = list_entry(clp->cl_sessions.next, struct nfsd4_session,
1087 se_perclnt);
1088 list_del(&ses->se_perclnt);
Benny Halevy508dc6e2012-02-23 17:40:52 -08001089 nfsd4_put_session_locked(ses);
J. Bruce Fields792c95d2010-10-12 19:55:25 -04001090 }
J. Bruce Fields03a4e1f2012-05-14 19:55:22 -04001091 free_svc_cred(&clp->cl_cred);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001092 kfree(clp->cl_name.data);
1093 kfree(clp);
1094}
1095
Benny Halevyd7682982010-05-12 00:13:54 +03001096void
1097release_session_client(struct nfsd4_session *session)
1098{
1099 struct nfs4_client *clp = session->se_client;
1100
1101 if (!atomic_dec_and_lock(&clp->cl_refcount, &client_lock))
1102 return;
1103 if (is_client_expired(clp)) {
1104 free_client(clp);
1105 session->se_client = NULL;
1106 } else
1107 renew_client_locked(clp);
1108 spin_unlock(&client_lock);
Benny Halevyd7682982010-05-12 00:13:54 +03001109}
1110
Benny Halevy84d38ac2010-05-12 00:13:16 +03001111/* must be called under the client_lock */
1112static inline void
1113unhash_client_locked(struct nfs4_client *clp)
1114{
J. Bruce Fields792c95d2010-10-12 19:55:25 -04001115 struct nfsd4_session *ses;
1116
Benny Halevy07cd4902010-05-12 00:13:41 +03001117 mark_client_expired(clp);
Benny Halevy84d38ac2010-05-12 00:13:16 +03001118 list_del(&clp->cl_lru);
J. Bruce Fields4c649372010-06-15 14:22:37 -04001119 spin_lock(&clp->cl_lock);
J. Bruce Fields792c95d2010-10-12 19:55:25 -04001120 list_for_each_entry(ses, &clp->cl_sessions, se_perclnt)
1121 list_del_init(&ses->se_hash);
J. Bruce Fields4c649372010-06-15 14:22:37 -04001122 spin_unlock(&clp->cl_lock);
Benny Halevy84d38ac2010-05-12 00:13:16 +03001123}
1124
Linus Torvalds1da177e2005-04-16 15:20:36 -07001125static void
1126expire_client(struct nfs4_client *clp)
1127{
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04001128 struct nfs4_openowner *oo;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001129 struct nfs4_delegation *dp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001130 struct list_head reaplist;
1131
Linus Torvalds1da177e2005-04-16 15:20:36 -07001132 INIT_LIST_HEAD(&reaplist);
1133 spin_lock(&recall_lock);
NeilBrownea1da632005-06-23 22:04:17 -07001134 while (!list_empty(&clp->cl_delegations)) {
1135 dp = list_entry(clp->cl_delegations.next, struct nfs4_delegation, dl_perclnt);
NeilBrownea1da632005-06-23 22:04:17 -07001136 list_del_init(&dp->dl_perclnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001137 list_move(&dp->dl_recall_lru, &reaplist);
1138 }
1139 spin_unlock(&recall_lock);
1140 while (!list_empty(&reaplist)) {
1141 dp = list_entry(reaplist.next, struct nfs4_delegation, dl_recall_lru);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001142 unhash_delegation(dp);
1143 }
NeilBrownea1da632005-06-23 22:04:17 -07001144 while (!list_empty(&clp->cl_openowners)) {
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04001145 oo = list_entry(clp->cl_openowners.next, struct nfs4_openowner, oo_perclient);
1146 release_openowner(oo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001147 }
J. Bruce Fields6ff8da02010-06-04 20:04:45 -04001148 nfsd4_shutdown_callback(clp);
J. Bruce Fields2bf23872010-03-08 12:37:27 -05001149 if (clp->cl_cb_conn.cb_xprt)
1150 svc_xprt_put(clp->cl_cb_conn.cb_xprt);
Benny Halevy84d38ac2010-05-12 00:13:16 +03001151 list_del(&clp->cl_idhash);
1152 list_del(&clp->cl_strhash);
1153 spin_lock(&client_lock);
1154 unhash_client_locked(clp);
Benny Halevy46583e22010-05-12 00:13:29 +03001155 if (atomic_read(&clp->cl_refcount) == 0)
1156 free_client(clp);
Benny Halevy84d38ac2010-05-12 00:13:16 +03001157 spin_unlock(&client_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001158}
1159
J. Bruce Fields35bba9a2007-11-21 22:07:08 -05001160static void copy_verf(struct nfs4_client *target, nfs4_verifier *source)
1161{
1162 memcpy(target->cl_verifier.data, source->data,
1163 sizeof(target->cl_verifier.data));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001164}
1165
J. Bruce Fields35bba9a2007-11-21 22:07:08 -05001166static void copy_clid(struct nfs4_client *target, struct nfs4_client *source)
1167{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001168 target->cl_clientid.cl_boot = source->cl_clientid.cl_boot;
1169 target->cl_clientid.cl_id = source->cl_clientid.cl_id;
1170}
1171
J. Bruce Fields03a4e1f2012-05-14 19:55:22 -04001172static int copy_cred(struct svc_cred *target, struct svc_cred *source)
J. Bruce Fields35bba9a2007-11-21 22:07:08 -05001173{
J. Bruce Fields03a4e1f2012-05-14 19:55:22 -04001174 if (source->cr_principal) {
1175 target->cr_principal =
1176 kstrdup(source->cr_principal, GFP_KERNEL);
1177 if (target->cr_principal == NULL)
1178 return -ENOMEM;
1179 } else
1180 target->cr_principal = NULL;
J. Bruce Fieldsd5497fc2012-05-14 22:06:49 -04001181 target->cr_flavor = source->cr_flavor;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001182 target->cr_uid = source->cr_uid;
1183 target->cr_gid = source->cr_gid;
1184 target->cr_group_info = source->cr_group_info;
1185 get_group_info(target->cr_group_info);
J. Bruce Fields03a4e1f2012-05-14 19:55:22 -04001186 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001187}
1188
J. Bruce Fields35bba9a2007-11-21 22:07:08 -05001189static int same_name(const char *n1, const char *n2)
J. Bruce Fields599e0a22007-07-26 17:04:54 -04001190{
NeilBrowna55370a2005-06-23 22:03:52 -07001191 return 0 == memcmp(n1, n2, HEXDIR_LEN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001192}
1193
1194static int
J. Bruce Fields599e0a22007-07-26 17:04:54 -04001195same_verf(nfs4_verifier *v1, nfs4_verifier *v2)
1196{
1197 return 0 == memcmp(v1->data, v2->data, sizeof(v1->data));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001198}
1199
1200static int
J. Bruce Fields599e0a22007-07-26 17:04:54 -04001201same_clid(clientid_t *cl1, clientid_t *cl2)
1202{
1203 return (cl1->cl_boot == cl2->cl_boot) && (cl1->cl_id == cl2->cl_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001204}
1205
J. Bruce Fields8fbba962012-05-14 21:20:54 -04001206static bool groups_equal(struct group_info *g1, struct group_info *g2)
1207{
1208 int i;
1209
1210 if (g1->ngroups != g2->ngroups)
1211 return false;
1212 for (i=0; i<g1->ngroups; i++)
1213 if (GROUP_AT(g1, i) != GROUP_AT(g2, i))
1214 return false;
1215 return true;
1216}
1217
Linus Torvalds1da177e2005-04-16 15:20:36 -07001218static int
J. Bruce Fields599e0a22007-07-26 17:04:54 -04001219same_creds(struct svc_cred *cr1, struct svc_cred *cr2)
1220{
J. Bruce Fieldsd5497fc2012-05-14 22:06:49 -04001221 if ((cr1->cr_flavor != cr2->cr_flavor)
1222 || (cr1->cr_uid != cr2->cr_uid)
J. Bruce Fields8fbba962012-05-14 21:20:54 -04001223 || (cr1->cr_gid != cr2->cr_gid)
1224 || !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;
1230 return 0 == strcmp(cr1->cr_principal, cr1->cr_principal);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001231}
1232
J. Bruce Fields5ec7b462007-11-21 21:58:56 -05001233static void gen_clid(struct nfs4_client *clp)
1234{
1235 static u32 current_clientid = 1;
1236
Linus Torvalds1da177e2005-04-16 15:20:36 -07001237 clp->cl_clientid.cl_boot = boot_time;
1238 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 Fields38c2f4b2011-09-23 17:01:19 -04001253 return idr_find(&cl->cl_stateids, t->si_opaque.so_id);
J. Bruce Fields4d71ab82011-09-06 16:48:57 -04001254}
1255
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04001256static struct nfs4_stid *find_stateid_by_type(struct nfs4_client *cl, stateid_t *t, char typemask)
J. Bruce Fieldsf459e452011-09-09 09:06:12 -04001257{
1258 struct nfs4_stid *s;
1259
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04001260 s = find_stateid(cl, t);
J. Bruce Fieldsf459e452011-09-09 09:06:12 -04001261 if (!s)
1262 return NULL;
1263 if (typemask & s->sc_type)
J. Bruce Fields4d71ab82011-09-06 16:48:57 -04001264 return s;
J. Bruce Fields4581d142011-09-06 14:56:09 -04001265 return NULL;
1266}
1267
Ricardo Labiagab09333c2009-09-10 12:27:34 +03001268static struct nfs4_client *create_client(struct xdr_netobj name, char *recdir,
1269 struct svc_rqst *rqstp, nfs4_verifier *verf)
1270{
1271 struct nfs4_client *clp;
1272 struct sockaddr *sa = svc_addr(rqstp);
J. Bruce Fields03a4e1f2012-05-14 19:55:22 -04001273 int ret;
Ricardo Labiagab09333c2009-09-10 12:27:34 +03001274
1275 clp = alloc_client(name);
1276 if (clp == NULL)
1277 return NULL;
1278
J. Bruce Fields792c95d2010-10-12 19:55:25 -04001279 INIT_LIST_HEAD(&clp->cl_sessions);
J. Bruce Fields03a4e1f2012-05-14 19:55:22 -04001280 ret = copy_cred(&clp->cl_cred, &rqstp->rq_cred);
1281 if (ret) {
1282 spin_lock(&client_lock);
1283 free_client(clp);
1284 spin_unlock(&client_lock);
1285 return NULL;
Ricardo Labiagab09333c2009-09-10 12:27:34 +03001286 }
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04001287 idr_init(&clp->cl_stateids);
Ricardo Labiagab09333c2009-09-10 12:27:34 +03001288 memcpy(clp->cl_recdir, recdir, HEXDIR_LEN);
Benny Halevy46583e22010-05-12 00:13:29 +03001289 atomic_set(&clp->cl_refcount, 0);
J. Bruce Fields77a35692010-04-30 18:51:44 -04001290 clp->cl_cb_state = NFSD4_CB_UNKNOWN;
Ricardo Labiagab09333c2009-09-10 12:27:34 +03001291 INIT_LIST_HEAD(&clp->cl_idhash);
1292 INIT_LIST_HEAD(&clp->cl_strhash);
1293 INIT_LIST_HEAD(&clp->cl_openowners);
1294 INIT_LIST_HEAD(&clp->cl_delegations);
Ricardo Labiagab09333c2009-09-10 12:27:34 +03001295 INIT_LIST_HEAD(&clp->cl_lru);
J. Bruce Fields5ce8ba22011-01-10 16:44:41 -05001296 INIT_LIST_HEAD(&clp->cl_callbacks);
J. Bruce Fields6ff8da02010-06-04 20:04:45 -04001297 spin_lock_init(&clp->cl_lock);
J. Bruce Fieldscee277d2010-05-26 17:52:14 -04001298 INIT_WORK(&clp->cl_cb_null.cb_work, nfsd4_do_callback_rpc);
Benny Halevy07cd4902010-05-12 00:13:41 +03001299 clp->cl_time = get_seconds();
Ricardo Labiagab09333c2009-09-10 12:27:34 +03001300 clear_bit(0, &clp->cl_cb_slot_busy);
1301 rpc_init_wait_queue(&clp->cl_cb_waitq, "Backchannel slot table");
1302 copy_verf(clp, verf);
1303 rpc_copy_addr((struct sockaddr *) &clp->cl_addr, sa);
Ricardo Labiagab09333c2009-09-10 12:27:34 +03001304 gen_confirm(clp);
J. Bruce Fieldsedd76782010-06-14 22:26:31 -04001305 clp->cl_cb_session = NULL;
Ricardo Labiagab09333c2009-09-10 12:27:34 +03001306 return clp;
1307}
1308
NeilBrownfd39ca92005-06-23 22:04:03 -07001309static void
Linus Torvalds1da177e2005-04-16 15:20:36 -07001310add_to_unconfirmed(struct nfs4_client *clp, unsigned int strhashval)
1311{
1312 unsigned int idhashval;
1313
1314 list_add(&clp->cl_strhash, &unconf_str_hashtbl[strhashval]);
1315 idhashval = clientid_hashval(clp->cl_clientid.cl_id);
1316 list_add(&clp->cl_idhash, &unconf_id_hashtbl[idhashval]);
Benny Halevy36acb662010-05-12 00:13:04 +03001317 renew_client(clp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001318}
1319
NeilBrownfd39ca92005-06-23 22:04:03 -07001320static void
Linus Torvalds1da177e2005-04-16 15:20:36 -07001321move_to_confirmed(struct nfs4_client *clp)
1322{
1323 unsigned int idhashval = clientid_hashval(clp->cl_clientid.cl_id);
1324 unsigned int strhashval;
1325
1326 dprintk("NFSD: move_to_confirm nfs4_client %p\n", clp);
Akinobu Mitaf1166292006-06-26 00:24:46 -07001327 list_move(&clp->cl_idhash, &conf_id_hashtbl[idhashval]);
NeilBrowna55370a2005-06-23 22:03:52 -07001328 strhashval = clientstr_hashval(clp->cl_recdir);
Benny Halevy328efba2010-05-12 00:12:51 +03001329 list_move(&clp->cl_strhash, &conf_str_hashtbl[strhashval]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001330 renew_client(clp);
1331}
1332
1333static struct nfs4_client *
1334find_confirmed_client(clientid_t *clid)
1335{
1336 struct nfs4_client *clp;
1337 unsigned int idhashval = clientid_hashval(clid->cl_id);
1338
1339 list_for_each_entry(clp, &conf_id_hashtbl[idhashval], cl_idhash) {
J. Bruce Fieldsa50d2ad2011-10-12 16:24:27 -04001340 if (same_clid(&clp->cl_clientid, clid)) {
1341 renew_client(clp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001342 return clp;
J. Bruce Fieldsa50d2ad2011-10-12 16:24:27 -04001343 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001344 }
1345 return NULL;
1346}
1347
1348static struct nfs4_client *
1349find_unconfirmed_client(clientid_t *clid)
1350{
1351 struct nfs4_client *clp;
1352 unsigned int idhashval = clientid_hashval(clid->cl_id);
1353
1354 list_for_each_entry(clp, &unconf_id_hashtbl[idhashval], cl_idhash) {
J. Bruce Fields599e0a22007-07-26 17:04:54 -04001355 if (same_clid(&clp->cl_clientid, clid))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001356 return clp;
1357 }
1358 return NULL;
1359}
1360
J. Bruce Fields6e5f15c2010-11-24 17:17:34 -05001361static bool clp_used_exchangeid(struct nfs4_client *clp)
Andy Adamsona1bcecd2009-04-03 08:28:05 +03001362{
J. Bruce Fields6e5f15c2010-11-24 17:17:34 -05001363 return clp->cl_exchange_flags != 0;
J. Bruce Fieldse203d502010-11-24 17:30:54 -05001364}
Andy Adamsona1bcecd2009-04-03 08:28:05 +03001365
NeilBrown28ce6052005-06-23 22:03:56 -07001366static struct nfs4_client *
J. Bruce Fieldse203d502010-11-24 17:30:54 -05001367find_confirmed_client_by_str(const char *dname, unsigned int hashval)
NeilBrown28ce6052005-06-23 22:03:56 -07001368{
1369 struct nfs4_client *clp;
1370
1371 list_for_each_entry(clp, &conf_str_hashtbl[hashval], cl_strhash) {
J. Bruce Fieldse203d502010-11-24 17:30:54 -05001372 if (same_name(clp->cl_recdir, dname))
NeilBrown28ce6052005-06-23 22:03:56 -07001373 return clp;
1374 }
1375 return NULL;
1376}
1377
1378static struct nfs4_client *
J. Bruce Fieldse203d502010-11-24 17:30:54 -05001379find_unconfirmed_client_by_str(const char *dname, unsigned int hashval)
NeilBrown28ce6052005-06-23 22:03:56 -07001380{
1381 struct nfs4_client *clp;
1382
1383 list_for_each_entry(clp, &unconf_str_hashtbl[hashval], cl_strhash) {
J. Bruce Fieldse203d502010-11-24 17:30:54 -05001384 if (same_name(clp->cl_recdir, dname))
NeilBrown28ce6052005-06-23 22:03:56 -07001385 return clp;
1386 }
1387 return NULL;
1388}
1389
NeilBrownfd39ca92005-06-23 22:04:03 -07001390static void
Takuma Umeya6f3d7722010-12-15 14:09:01 +09001391gen_callback(struct nfs4_client *clp, struct nfsd4_setclientid *se, struct svc_rqst *rqstp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001392{
J. Bruce Fields07263f12010-05-31 19:09:40 -04001393 struct nfs4_cb_conn *conn = &clp->cl_cb_conn;
Takuma Umeya6f3d7722010-12-15 14:09:01 +09001394 struct sockaddr *sa = svc_addr(rqstp);
1395 u32 scopeid = rpc_get_scope_id(sa);
Jeff Layton7077ecb2009-08-14 12:57:58 -04001396 unsigned short expected_family;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001397
Jeff Layton7077ecb2009-08-14 12:57:58 -04001398 /* Currently, we only support tcp and tcp6 for the callback channel */
1399 if (se->se_callback_netid_len == 3 &&
1400 !memcmp(se->se_callback_netid_val, "tcp", 3))
1401 expected_family = AF_INET;
1402 else if (se->se_callback_netid_len == 4 &&
1403 !memcmp(se->se_callback_netid_val, "tcp6", 4))
1404 expected_family = AF_INET6;
1405 else
Linus Torvalds1da177e2005-04-16 15:20:36 -07001406 goto out_err;
1407
Stanislav Kinsburskyf2ac4dc2012-01-13 13:09:27 +04001408 conn->cb_addrlen = rpc_uaddr2sockaddr(&init_net, se->se_callback_addr_val,
Jeff Laytonaa9a4ec2009-08-14 12:57:57 -04001409 se->se_callback_addr_len,
J. Bruce Fields07263f12010-05-31 19:09:40 -04001410 (struct sockaddr *)&conn->cb_addr,
1411 sizeof(conn->cb_addr));
Jeff Laytonaa9a4ec2009-08-14 12:57:57 -04001412
J. Bruce Fields07263f12010-05-31 19:09:40 -04001413 if (!conn->cb_addrlen || conn->cb_addr.ss_family != expected_family)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001414 goto out_err;
Jeff Laytonaa9a4ec2009-08-14 12:57:57 -04001415
J. Bruce Fields07263f12010-05-31 19:09:40 -04001416 if (conn->cb_addr.ss_family == AF_INET6)
1417 ((struct sockaddr_in6 *)&conn->cb_addr)->sin6_scope_id = scopeid;
Jeff Laytonfbf46652009-08-14 12:57:59 -04001418
J. Bruce Fields07263f12010-05-31 19:09:40 -04001419 conn->cb_prog = se->se_callback_prog;
1420 conn->cb_ident = se->se_callback_ident;
Mi Jinlong849a1cf2011-08-30 17:18:41 +08001421 memcpy(&conn->cb_saddr, &rqstp->rq_daddr, rqstp->rq_daddrlen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001422 return;
1423out_err:
J. Bruce Fields07263f12010-05-31 19:09:40 -04001424 conn->cb_addr.ss_family = AF_UNSPEC;
1425 conn->cb_addrlen = 0;
Neil Brown849823c2005-09-13 01:25:36 -07001426 dprintk(KERN_INFO "NFSD: this client (clientid %08x/%08x) "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001427 "will not receive delegations\n",
1428 clp->cl_clientid.cl_boot, clp->cl_clientid.cl_id);
1429
Linus Torvalds1da177e2005-04-16 15:20:36 -07001430 return;
1431}
1432
Andy Adamson074fe892009-04-03 08:28:15 +03001433/*
Andy Adamson557ce262009-08-28 08:45:04 -04001434 * Cache a reply. nfsd4_check_drc_limit() has bounded the cache size.
Andy Adamson074fe892009-04-03 08:28:15 +03001435 */
1436void
1437nfsd4_store_cache_entry(struct nfsd4_compoundres *resp)
1438{
Andy Adamson557ce262009-08-28 08:45:04 -04001439 struct nfsd4_slot *slot = resp->cstate.slot;
1440 unsigned int base;
Andy Adamson074fe892009-04-03 08:28:15 +03001441
Andy Adamson557ce262009-08-28 08:45:04 -04001442 dprintk("--> %s slot %p\n", __func__, slot);
Andy Adamson074fe892009-04-03 08:28:15 +03001443
Andy Adamson557ce262009-08-28 08:45:04 -04001444 slot->sl_opcnt = resp->opcnt;
1445 slot->sl_status = resp->cstate.status;
Andy Adamsonbf864a32009-04-03 08:28:35 +03001446
J. Bruce Fieldsbf5c43c2012-02-13 16:56:19 -05001447 slot->sl_flags |= NFSD4_SLOT_INITIALIZED;
Andy Adamsonbf864a32009-04-03 08:28:35 +03001448 if (nfsd4_not_cached(resp)) {
Andy Adamson557ce262009-08-28 08:45:04 -04001449 slot->sl_datalen = 0;
Andy Adamsonbf864a32009-04-03 08:28:35 +03001450 return;
1451 }
Andy Adamson557ce262009-08-28 08:45:04 -04001452 slot->sl_datalen = (char *)resp->p - (char *)resp->cstate.datap;
1453 base = (char *)resp->cstate.datap -
1454 (char *)resp->xbuf->head[0].iov_base;
1455 if (read_bytes_from_xdr_buf(resp->xbuf, base, slot->sl_data,
1456 slot->sl_datalen))
1457 WARN("%s: sessions DRC could not cache compound\n", __func__);
1458 return;
Andy Adamson074fe892009-04-03 08:28:15 +03001459}
1460
1461/*
Andy Adamsonabfabf82009-07-23 19:02:18 -04001462 * Encode the replay sequence operation from the slot values.
1463 * If cachethis is FALSE encode the uncached rep error on the next
1464 * operation which sets resp->p and increments resp->opcnt for
1465 * nfs4svc_encode_compoundres.
1466 *
Andy Adamson074fe892009-04-03 08:28:15 +03001467 */
Andy Adamsonabfabf82009-07-23 19:02:18 -04001468static __be32
1469nfsd4_enc_sequence_replay(struct nfsd4_compoundargs *args,
1470 struct nfsd4_compoundres *resp)
Andy Adamson074fe892009-04-03 08:28:15 +03001471{
Andy Adamsonabfabf82009-07-23 19:02:18 -04001472 struct nfsd4_op *op;
1473 struct nfsd4_slot *slot = resp->cstate.slot;
Andy Adamson074fe892009-04-03 08:28:15 +03001474
Andy Adamsonabfabf82009-07-23 19:02:18 -04001475 /* Encode the replayed sequence operation */
1476 op = &args->ops[resp->opcnt - 1];
1477 nfsd4_encode_operation(resp, op);
1478
1479 /* Return nfserr_retry_uncached_rep in next operation. */
J. Bruce Fields73e79482012-02-13 16:39:00 -05001480 if (args->opcnt > 1 && !(slot->sl_flags & NFSD4_SLOT_CACHETHIS)) {
Andy Adamsonabfabf82009-07-23 19:02:18 -04001481 op = &args->ops[resp->opcnt++];
1482 op->status = nfserr_retry_uncached_rep;
1483 nfsd4_encode_operation(resp, op);
Andy Adamson074fe892009-04-03 08:28:15 +03001484 }
Andy Adamsonabfabf82009-07-23 19:02:18 -04001485 return op->status;
Andy Adamson074fe892009-04-03 08:28:15 +03001486}
1487
1488/*
Andy Adamson557ce262009-08-28 08:45:04 -04001489 * The sequence operation is not cached because we can use the slot and
1490 * session values.
Andy Adamson074fe892009-04-03 08:28:15 +03001491 */
1492__be32
Andy Adamsonbf864a32009-04-03 08:28:35 +03001493nfsd4_replay_cache_entry(struct nfsd4_compoundres *resp,
1494 struct nfsd4_sequence *seq)
Andy Adamson074fe892009-04-03 08:28:15 +03001495{
Andy Adamson557ce262009-08-28 08:45:04 -04001496 struct nfsd4_slot *slot = resp->cstate.slot;
Andy Adamson074fe892009-04-03 08:28:15 +03001497 __be32 status;
1498
Andy Adamson557ce262009-08-28 08:45:04 -04001499 dprintk("--> %s slot %p\n", __func__, slot);
Andy Adamson074fe892009-04-03 08:28:15 +03001500
Andy Adamsonabfabf82009-07-23 19:02:18 -04001501 /* Either returns 0 or nfserr_retry_uncached */
1502 status = nfsd4_enc_sequence_replay(resp->rqstp->rq_argp, resp);
1503 if (status == nfserr_retry_uncached_rep)
1504 return status;
Andy Adamson074fe892009-04-03 08:28:15 +03001505
Andy Adamson557ce262009-08-28 08:45:04 -04001506 /* The sequence operation has been encoded, cstate->datap set. */
1507 memcpy(resp->cstate.datap, slot->sl_data, slot->sl_datalen);
Andy Adamson074fe892009-04-03 08:28:15 +03001508
Andy Adamson557ce262009-08-28 08:45:04 -04001509 resp->opcnt = slot->sl_opcnt;
1510 resp->p = resp->cstate.datap + XDR_QUADLEN(slot->sl_datalen);
1511 status = slot->sl_status;
Andy Adamson074fe892009-04-03 08:28:15 +03001512
1513 return status;
1514}
1515
Andy Adamson0733d212009-04-03 08:28:01 +03001516/*
1517 * Set the exchange_id flags returned by the server.
1518 */
1519static void
1520nfsd4_set_ex_flags(struct nfs4_client *new, struct nfsd4_exchange_id *clid)
1521{
1522 /* pNFS is not supported */
1523 new->cl_exchange_flags |= EXCHGID4_FLAG_USE_NON_PNFS;
1524
1525 /* Referrals are supported, Migration is not. */
1526 new->cl_exchange_flags |= EXCHGID4_FLAG_SUPP_MOVED_REFER;
1527
1528 /* set the wire flags to return to client. */
1529 clid->flags = new->cl_exchange_flags;
1530}
1531
J. Bruce Fields631fc9e2012-05-14 15:57:23 -04001532static bool client_has_state(struct nfs4_client *clp)
1533{
1534 /*
1535 * Note clp->cl_openowners check isn't quite right: there's no
1536 * need to count owners without stateid's.
1537 *
1538 * Also note we should probably be using this in 4.0 case too.
1539 */
1540 return list_empty(&clp->cl_openowners)
1541 && list_empty(&clp->cl_delegations)
1542 && list_empty(&clp->cl_sessions);
1543}
1544
Al Virob37ad282006-10-19 23:28:59 -07001545__be32
Andy Adamson069b6ad2009-04-03 08:27:58 +03001546nfsd4_exchange_id(struct svc_rqst *rqstp,
1547 struct nfsd4_compound_state *cstate,
1548 struct nfsd4_exchange_id *exid)
1549{
Andy Adamson0733d212009-04-03 08:28:01 +03001550 struct nfs4_client *unconf, *conf, *new;
J. Bruce Fields57b7b432012-04-25 17:58:50 -04001551 __be32 status;
Andy Adamson0733d212009-04-03 08:28:01 +03001552 unsigned int strhashval;
1553 char dname[HEXDIR_LEN];
Jeff Layton363168b2009-08-14 12:57:56 -04001554 char addr_str[INET6_ADDRSTRLEN];
Andy Adamson0733d212009-04-03 08:28:01 +03001555 nfs4_verifier verf = exid->verifier;
Jeff Layton363168b2009-08-14 12:57:56 -04001556 struct sockaddr *sa = svc_addr(rqstp);
J. Bruce Fields83e08fd2012-05-14 09:08:10 -04001557 bool update = exid->flags & EXCHGID4_FLAG_UPD_CONFIRMED_REC_A;
Andy Adamson0733d212009-04-03 08:28:01 +03001558
Jeff Layton363168b2009-08-14 12:57:56 -04001559 rpc_ntop(sa, addr_str, sizeof(addr_str));
Andy Adamson0733d212009-04-03 08:28:01 +03001560 dprintk("%s rqstp=%p exid=%p clname.len=%u clname.data=%p "
Jeff Layton363168b2009-08-14 12:57:56 -04001561 "ip_addr=%s flags %x, spa_how %d\n",
Andy Adamson0733d212009-04-03 08:28:01 +03001562 __func__, rqstp, exid, exid->clname.len, exid->clname.data,
Jeff Layton363168b2009-08-14 12:57:56 -04001563 addr_str, exid->flags, exid->spa_how);
Andy Adamson0733d212009-04-03 08:28:01 +03001564
J. Bruce Fieldsa084daf2011-10-10 15:07:40 -04001565 if (exid->flags & ~EXCHGID4_FLAG_MASK_A)
Andy Adamson0733d212009-04-03 08:28:01 +03001566 return nfserr_inval;
1567
1568 /* Currently only support SP4_NONE */
1569 switch (exid->spa_how) {
1570 case SP4_NONE:
1571 break;
1572 case SP4_SSV:
J. Bruce Fields044bc1d2010-11-12 14:36:06 -05001573 return nfserr_serverfault;
Andy Adamson0733d212009-04-03 08:28:01 +03001574 default:
1575 BUG(); /* checked by xdr code */
1576 case SP4_MACH_CRED:
1577 return nfserr_serverfault; /* no excuse :-/ */
1578 }
1579
1580 status = nfs4_make_rec_clidname(dname, &exid->clname);
1581
1582 if (status)
J. Bruce Fields2786cc32012-05-12 20:53:20 -04001583 return status;
Andy Adamson0733d212009-04-03 08:28:01 +03001584
1585 strhashval = clientstr_hashval(dname);
1586
J. Bruce Fields2dbb2692012-05-14 09:47:11 -04001587 /* Cases below refer to rfc 5661 section 18.35.4: */
Andy Adamson0733d212009-04-03 08:28:01 +03001588 nfs4_lock_state();
J. Bruce Fieldse203d502010-11-24 17:30:54 -05001589 conf = find_confirmed_client_by_str(dname, strhashval);
Andy Adamson0733d212009-04-03 08:28:01 +03001590 if (conf) {
J. Bruce Fields83e08fd2012-05-14 09:08:10 -04001591 bool creds_match = same_creds(&conf->cl_cred, &rqstp->rq_cred);
1592 bool verfs_match = same_verf(&verf, &conf->cl_verifier);
1593
J. Bruce Fields136e6582012-05-12 20:37:23 -04001594 if (update) {
1595 if (!clp_used_exchangeid(conf)) { /* buggy client */
J. Bruce Fields2dbb2692012-05-14 09:47:11 -04001596 status = nfserr_inval;
J. Bruce Fields1a308112012-05-12 21:32:30 -04001597 goto out;
1598 }
J. Bruce Fields136e6582012-05-12 20:37:23 -04001599 if (!creds_match) { /* case 9 */
J. Bruce Fieldsea236d02012-05-12 21:08:41 -04001600 status = nfserr_perm;
J. Bruce Fields136e6582012-05-12 20:37:23 -04001601 goto out;
1602 }
1603 if (!verfs_match) { /* case 8 */
Andy Adamson0733d212009-04-03 08:28:01 +03001604 status = nfserr_not_same;
1605 goto out;
1606 }
J. Bruce Fields136e6582012-05-12 20:37:23 -04001607 /* case 6 */
1608 exid->flags |= EXCHGID4_FLAG_CONFIRMED_R;
1609 new = conf;
1610 goto out_copy;
Andy Adamson0733d212009-04-03 08:28:01 +03001611 }
J. Bruce Fields136e6582012-05-12 20:37:23 -04001612 if (!creds_match) { /* case 3 */
J. Bruce Fields631fc9e2012-05-14 15:57:23 -04001613 if (client_has_state(conf)) {
1614 status = nfserr_clid_inuse;
1615 goto out;
1616 }
1617 goto expire_client;
J. Bruce Fields1a308112012-05-12 21:32:30 -04001618 }
J. Bruce Fields136e6582012-05-12 20:37:23 -04001619 if (verfs_match) { /* case 2 */
J. Bruce Fields0f1ba0e2012-05-25 21:24:40 -04001620 conf->cl_exchange_flags |= EXCHGID4_FLAG_CONFIRMED_R;
J. Bruce Fields136e6582012-05-12 20:37:23 -04001621 new = conf;
1622 goto out_copy;
1623 }
1624 /* case 5, client reboot */
J. Bruce Fields631fc9e2012-05-14 15:57:23 -04001625expire_client:
J. Bruce Fields136e6582012-05-12 20:37:23 -04001626 expire_client(conf);
1627 goto out_new;
Mike Sager6ddbbbf2009-06-16 04:20:47 +03001628 }
1629
J. Bruce Fields2dbb2692012-05-14 09:47:11 -04001630 if (update) { /* case 7 */
Mike Sager6ddbbbf2009-06-16 04:20:47 +03001631 status = nfserr_noent;
1632 goto out;
Andy Adamson0733d212009-04-03 08:28:01 +03001633 }
1634
J. Bruce Fieldse203d502010-11-24 17:30:54 -05001635 unconf = find_unconfirmed_client_by_str(dname, strhashval);
J. Bruce Fields2dbb2692012-05-14 09:47:11 -04001636 if (unconf) /* case 4, possible retry or client restart */
Andy Adamson0733d212009-04-03 08:28:01 +03001637 expire_client(unconf);
Andy Adamson0733d212009-04-03 08:28:01 +03001638
J. Bruce Fields2dbb2692012-05-14 09:47:11 -04001639 /* case 1 (normal case) */
Andy Adamson0733d212009-04-03 08:28:01 +03001640out_new:
Ricardo Labiagab09333c2009-09-10 12:27:34 +03001641 new = create_client(exid->clname, dname, rqstp, &verf);
Andy Adamson0733d212009-04-03 08:28:01 +03001642 if (new == NULL) {
J. Bruce Fields47310302010-06-22 16:17:12 -04001643 status = nfserr_jukebox;
Andy Adamson0733d212009-04-03 08:28:01 +03001644 goto out;
1645 }
1646
Andy Adamson0733d212009-04-03 08:28:01 +03001647 gen_clid(new);
Andy Adamson0733d212009-04-03 08:28:01 +03001648 add_to_unconfirmed(new, strhashval);
1649out_copy:
1650 exid->clientid.cl_boot = new->cl_clientid.cl_boot;
1651 exid->clientid.cl_id = new->cl_clientid.cl_id;
1652
Andy Adamson38eb76a2009-04-03 08:28:32 +03001653 exid->seqid = 1;
Andy Adamson0733d212009-04-03 08:28:01 +03001654 nfsd4_set_ex_flags(new, exid);
1655
1656 dprintk("nfsd4_exchange_id seqid %d flags %x\n",
Andy Adamson49557cc2009-07-23 19:02:16 -04001657 new->cl_cs_slot.sl_seqid, new->cl_exchange_flags);
Andy Adamson0733d212009-04-03 08:28:01 +03001658 status = nfs_ok;
1659
1660out:
1661 nfs4_unlock_state();
Andy Adamson0733d212009-04-03 08:28:01 +03001662 return status;
Andy Adamson069b6ad2009-04-03 08:27:58 +03001663}
1664
J. Bruce Fields57b7b432012-04-25 17:58:50 -04001665static __be32
Andy Adamson88e588d2009-07-23 19:02:15 -04001666check_slot_seqid(u32 seqid, u32 slot_seqid, int slot_inuse)
Benny Halevyb85d4c02009-04-03 08:28:08 +03001667{
Andy Adamson88e588d2009-07-23 19:02:15 -04001668 dprintk("%s enter. seqid %d slot_seqid %d\n", __func__, seqid,
1669 slot_seqid);
Benny Halevyb85d4c02009-04-03 08:28:08 +03001670
1671 /* The slot is in use, and no response has been sent. */
Andy Adamson88e588d2009-07-23 19:02:15 -04001672 if (slot_inuse) {
1673 if (seqid == slot_seqid)
Benny Halevyb85d4c02009-04-03 08:28:08 +03001674 return nfserr_jukebox;
1675 else
1676 return nfserr_seq_misordered;
1677 }
J. Bruce Fieldsf6d82482012-02-13 16:13:41 -05001678 /* Note unsigned 32-bit arithmetic handles wraparound: */
Andy Adamson88e588d2009-07-23 19:02:15 -04001679 if (likely(seqid == slot_seqid + 1))
Benny Halevyb85d4c02009-04-03 08:28:08 +03001680 return nfs_ok;
Andy Adamson88e588d2009-07-23 19:02:15 -04001681 if (seqid == slot_seqid)
Benny Halevyb85d4c02009-04-03 08:28:08 +03001682 return nfserr_replay_cache;
Benny Halevyb85d4c02009-04-03 08:28:08 +03001683 return nfserr_seq_misordered;
1684}
1685
Andy Adamson49557cc2009-07-23 19:02:16 -04001686/*
1687 * Cache the create session result into the create session single DRC
1688 * slot cache by saving the xdr structure. sl_seqid has been set.
1689 * Do this for solo or embedded create session operations.
1690 */
1691static void
1692nfsd4_cache_create_session(struct nfsd4_create_session *cr_ses,
J. Bruce Fields57b7b432012-04-25 17:58:50 -04001693 struct nfsd4_clid_slot *slot, __be32 nfserr)
Andy Adamson49557cc2009-07-23 19:02:16 -04001694{
1695 slot->sl_status = nfserr;
1696 memcpy(&slot->sl_cr_ses, cr_ses, sizeof(*cr_ses));
1697}
1698
1699static __be32
1700nfsd4_replay_create_session(struct nfsd4_create_session *cr_ses,
1701 struct nfsd4_clid_slot *slot)
1702{
1703 memcpy(cr_ses, &slot->sl_cr_ses, sizeof(*cr_ses));
1704 return slot->sl_status;
1705}
1706
Mi Jinlong1b74c252011-07-14 14:50:17 +08001707#define NFSD_MIN_REQ_HDR_SEQ_SZ ((\
1708 2 * 2 + /* credential,verifier: AUTH_NULL, length 0 */ \
1709 1 + /* MIN tag is length with zero, only length */ \
1710 3 + /* version, opcount, opcode */ \
1711 XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + \
1712 /* seqid, slotID, slotID, cache */ \
1713 4 ) * sizeof(__be32))
1714
1715#define NFSD_MIN_RESP_HDR_SEQ_SZ ((\
1716 2 + /* verifier: AUTH_NULL, length 0 */\
1717 1 + /* status */ \
1718 1 + /* MIN tag is length with zero, only length */ \
1719 3 + /* opcount, opcode, opstatus*/ \
1720 XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + \
1721 /* seqid, slotID, slotID, slotID, status */ \
1722 5 ) * sizeof(__be32))
1723
J. Bruce Fields57b7b432012-04-25 17:58:50 -04001724static bool check_forechannel_attrs(struct nfsd4_channel_attrs fchannel)
Mi Jinlong1b74c252011-07-14 14:50:17 +08001725{
1726 return fchannel.maxreq_sz < NFSD_MIN_REQ_HDR_SEQ_SZ
1727 || fchannel.maxresp_sz < NFSD_MIN_RESP_HDR_SEQ_SZ;
1728}
1729
Andy Adamson069b6ad2009-04-03 08:27:58 +03001730__be32
1731nfsd4_create_session(struct svc_rqst *rqstp,
1732 struct nfsd4_compound_state *cstate,
1733 struct nfsd4_create_session *cr_ses)
1734{
Jeff Layton363168b2009-08-14 12:57:56 -04001735 struct sockaddr *sa = svc_addr(rqstp);
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001736 struct nfs4_client *conf, *unconf;
J. Bruce Fieldsac7c46f22010-06-14 19:01:57 -04001737 struct nfsd4_session *new;
Andy Adamson49557cc2009-07-23 19:02:16 -04001738 struct nfsd4_clid_slot *cs_slot = NULL;
J. Bruce Fields86c3e162010-10-02 17:04:00 -04001739 bool confirm_me = false;
J. Bruce Fields57b7b432012-04-25 17:58:50 -04001740 __be32 status = 0;
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001741
Mi Jinlonga62573d2011-03-23 17:57:07 +08001742 if (cr_ses->flags & ~SESSION4_FLAG_MASK_A)
1743 return nfserr_inval;
1744
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001745 nfs4_lock_state();
1746 unconf = find_unconfirmed_client(&cr_ses->clientid);
1747 conf = find_confirmed_client(&cr_ses->clientid);
1748
1749 if (conf) {
Andy Adamson49557cc2009-07-23 19:02:16 -04001750 cs_slot = &conf->cl_cs_slot;
1751 status = check_slot_seqid(cr_ses->seqid, cs_slot->sl_seqid, 0);
Andy Adamson38eb76a2009-04-03 08:28:32 +03001752 if (status == nfserr_replay_cache) {
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001753 dprintk("Got a create_session replay! seqid= %d\n",
Andy Adamson49557cc2009-07-23 19:02:16 -04001754 cs_slot->sl_seqid);
Andy Adamson38eb76a2009-04-03 08:28:32 +03001755 /* Return the cached reply status */
Andy Adamson49557cc2009-07-23 19:02:16 -04001756 status = nfsd4_replay_create_session(cr_ses, cs_slot);
Andy Adamson38eb76a2009-04-03 08:28:32 +03001757 goto out;
Andy Adamson49557cc2009-07-23 19:02:16 -04001758 } else if (cr_ses->seqid != cs_slot->sl_seqid + 1) {
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001759 status = nfserr_seq_misordered;
1760 dprintk("Sequence misordered!\n");
1761 dprintk("Expected seqid= %d but got seqid= %d\n",
Andy Adamson49557cc2009-07-23 19:02:16 -04001762 cs_slot->sl_seqid, cr_ses->seqid);
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001763 goto out;
1764 }
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001765 } else if (unconf) {
1766 if (!same_creds(&unconf->cl_cred, &rqstp->rq_cred) ||
Jeff Layton363168b2009-08-14 12:57:56 -04001767 !rpc_cmp_addr(sa, (struct sockaddr *) &unconf->cl_addr)) {
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001768 status = nfserr_clid_inuse;
1769 goto out;
1770 }
1771
Andy Adamson49557cc2009-07-23 19:02:16 -04001772 cs_slot = &unconf->cl_cs_slot;
1773 status = check_slot_seqid(cr_ses->seqid, cs_slot->sl_seqid, 0);
Andy Adamson38eb76a2009-04-03 08:28:32 +03001774 if (status) {
1775 /* an unconfirmed replay returns misordered */
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001776 status = nfserr_seq_misordered;
J. Bruce Fieldscd5b8142010-10-02 17:03:35 -04001777 goto out;
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001778 }
1779
J. Bruce Fields86c3e162010-10-02 17:04:00 -04001780 confirm_me = true;
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001781 conf = unconf;
1782 } else {
1783 status = nfserr_stale_clientid;
1784 goto out;
1785 }
1786
J. Bruce Fields408b79b2010-04-15 15:11:09 -04001787 /*
J. Bruce Fields8323c3b2010-10-19 19:36:51 -04001788 * XXX: we should probably set this at creation time, and check
1789 * for consistent minorversion use throughout:
1790 */
1791 conf->cl_minorversion = 1;
1792 /*
J. Bruce Fields408b79b2010-04-15 15:11:09 -04001793 * We do not support RDMA or persistent sessions
1794 */
1795 cr_ses->flags &= ~SESSION4_PERSIST;
1796 cr_ses->flags &= ~SESSION4_RDMA;
1797
Mi Jinlong1b74c252011-07-14 14:50:17 +08001798 status = nfserr_toosmall;
1799 if (check_forechannel_attrs(cr_ses->fore_channel))
1800 goto out;
1801
J. Bruce Fieldsac7c46f22010-06-14 19:01:57 -04001802 status = nfserr_jukebox;
1803 new = alloc_init_session(rqstp, conf, cr_ses);
1804 if (!new)
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001805 goto out;
J. Bruce Fieldsac7c46f22010-06-14 19:01:57 -04001806 status = nfs_ok;
1807 memcpy(cr_ses->sessionid.data, new->se_sessionid.data,
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001808 NFS4_MAX_SESSIONID_LEN);
Mi Jinlong12050652010-11-11 18:03:40 +08001809 memcpy(&cr_ses->fore_channel, &new->se_fchannel,
1810 sizeof(struct nfsd4_channel_attrs));
J. Bruce Fields86c3e162010-10-02 17:04:00 -04001811 cs_slot->sl_seqid++;
Andy Adamson49557cc2009-07-23 19:02:16 -04001812 cr_ses->seqid = cs_slot->sl_seqid;
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001813
Andy Adamson49557cc2009-07-23 19:02:16 -04001814 /* cache solo and embedded create sessions under the state lock */
1815 nfsd4_cache_create_session(cr_ses, cs_slot, status);
J. Bruce Fields86c3e162010-10-02 17:04:00 -04001816 if (confirm_me)
1817 move_to_confirmed(conf);
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001818out:
1819 nfs4_unlock_state();
1820 dprintk("%s returns %d\n", __func__, ntohl(status));
1821 return status;
Andy Adamson069b6ad2009-04-03 08:27:58 +03001822}
1823
J. Bruce Fields57716352010-04-21 12:27:19 -04001824static bool nfsd4_last_compound_op(struct svc_rqst *rqstp)
1825{
1826 struct nfsd4_compoundres *resp = rqstp->rq_resp;
1827 struct nfsd4_compoundargs *argp = rqstp->rq_argp;
1828
1829 return argp->opcnt == resp->opcnt;
1830}
1831
J. Bruce Fields1d1bc8f2010-10-04 23:12:59 -04001832static __be32 nfsd4_map_bcts_dir(u32 *dir)
1833{
1834 switch (*dir) {
1835 case NFS4_CDFC4_FORE:
1836 case NFS4_CDFC4_BACK:
1837 return nfs_ok;
1838 case NFS4_CDFC4_FORE_OR_BOTH:
1839 case NFS4_CDFC4_BACK_OR_BOTH:
1840 *dir = NFS4_CDFC4_BOTH;
1841 return nfs_ok;
1842 };
1843 return nfserr_inval;
1844}
1845
1846__be32 nfsd4_bind_conn_to_session(struct svc_rqst *rqstp,
1847 struct nfsd4_compound_state *cstate,
1848 struct nfsd4_bind_conn_to_session *bcts)
1849{
1850 __be32 status;
1851
1852 if (!nfsd4_last_compound_op(rqstp))
1853 return nfserr_not_only_op;
1854 spin_lock(&client_lock);
1855 cstate->session = find_in_sessionid_hashtbl(&bcts->sessionid);
1856 /* Sorta weird: we only need the refcnt'ing because new_conn acquires
1857 * client_lock iself: */
1858 if (cstate->session) {
1859 nfsd4_get_session(cstate->session);
1860 atomic_inc(&cstate->session->se_client->cl_refcount);
1861 }
1862 spin_unlock(&client_lock);
1863 if (!cstate->session)
1864 return nfserr_badsession;
1865
1866 status = nfsd4_map_bcts_dir(&bcts->dir);
Bryan Schumaker1db2b9d2011-04-27 15:47:15 -04001867 if (!status)
1868 nfsd4_new_conn(rqstp, cstate->session, bcts->dir);
1869 return status;
J. Bruce Fields1d1bc8f2010-10-04 23:12:59 -04001870}
1871
J. Bruce Fields5d4cec22010-05-01 12:56:06 -04001872static bool nfsd4_compound_in_session(struct nfsd4_session *session, struct nfs4_sessionid *sid)
1873{
1874 if (!session)
1875 return 0;
1876 return !memcmp(sid, &session->se_sessionid, sizeof(*sid));
1877}
1878
Andy Adamson069b6ad2009-04-03 08:27:58 +03001879__be32
1880nfsd4_destroy_session(struct svc_rqst *r,
1881 struct nfsd4_compound_state *cstate,
1882 struct nfsd4_destroy_session *sessionid)
1883{
Benny Halevye10e0cf2009-04-03 08:28:38 +03001884 struct nfsd4_session *ses;
J. Bruce Fields57b7b432012-04-25 17:58:50 -04001885 __be32 status = nfserr_badsession;
Benny Halevye10e0cf2009-04-03 08:28:38 +03001886
1887 /* Notes:
1888 * - The confirmed nfs4_client->cl_sessionid holds destroyed sessinid
1889 * - Should we return nfserr_back_chan_busy if waiting for
1890 * callbacks on to-be-destroyed session?
1891 * - Do we need to clear any callback info from previous session?
1892 */
1893
J. Bruce Fields5d4cec22010-05-01 12:56:06 -04001894 if (nfsd4_compound_in_session(cstate->session, &sessionid->sessionid)) {
J. Bruce Fields57716352010-04-21 12:27:19 -04001895 if (!nfsd4_last_compound_op(r))
1896 return nfserr_not_only_op;
1897 }
Benny Halevye10e0cf2009-04-03 08:28:38 +03001898 dump_sessionid(__func__, &sessionid->sessionid);
Benny Halevy9089f1b2010-05-12 00:12:26 +03001899 spin_lock(&client_lock);
Benny Halevye10e0cf2009-04-03 08:28:38 +03001900 ses = find_in_sessionid_hashtbl(&sessionid->sessionid);
1901 if (!ses) {
Benny Halevy9089f1b2010-05-12 00:12:26 +03001902 spin_unlock(&client_lock);
Benny Halevye10e0cf2009-04-03 08:28:38 +03001903 goto out;
1904 }
1905
1906 unhash_session(ses);
Benny Halevy9089f1b2010-05-12 00:12:26 +03001907 spin_unlock(&client_lock);
Benny Halevye10e0cf2009-04-03 08:28:38 +03001908
Benny Halevyab707e152010-05-12 00:14:06 +03001909 nfs4_lock_state();
J. Bruce Fields84f5f7c2010-12-09 15:52:19 -05001910 nfsd4_probe_callback_sync(ses->se_client);
Benny Halevyab707e152010-05-12 00:14:06 +03001911 nfs4_unlock_state();
J. Bruce Fields19cf5c02010-06-06 18:37:16 -04001912
Benny Halevy508dc6e2012-02-23 17:40:52 -08001913 spin_lock(&client_lock);
J. Bruce Fields19cf5c02010-06-06 18:37:16 -04001914 nfsd4_del_conns(ses);
Benny Halevy508dc6e2012-02-23 17:40:52 -08001915 nfsd4_put_session_locked(ses);
1916 spin_unlock(&client_lock);
Benny Halevye10e0cf2009-04-03 08:28:38 +03001917 status = nfs_ok;
1918out:
1919 dprintk("%s returns %d\n", __func__, ntohl(status));
1920 return status;
Andy Adamson069b6ad2009-04-03 08:27:58 +03001921}
1922
J. Bruce Fieldsa663bdd2010-10-21 17:17:31 -04001923static struct nfsd4_conn *__nfsd4_find_conn(struct svc_xprt *xpt, struct nfsd4_session *s)
J. Bruce Fields328ead22010-09-29 16:11:06 -04001924{
1925 struct nfsd4_conn *c;
1926
1927 list_for_each_entry(c, &s->se_conns, cn_persession) {
J. Bruce Fieldsa663bdd2010-10-21 17:17:31 -04001928 if (c->cn_xprt == xpt) {
J. Bruce Fields328ead22010-09-29 16:11:06 -04001929 return c;
1930 }
1931 }
1932 return NULL;
1933}
1934
J. Bruce Fieldsa663bdd2010-10-21 17:17:31 -04001935static void nfsd4_sequence_check_conn(struct nfsd4_conn *new, struct nfsd4_session *ses)
J. Bruce Fields328ead22010-09-29 16:11:06 -04001936{
1937 struct nfs4_client *clp = ses->se_client;
J. Bruce Fieldsa663bdd2010-10-21 17:17:31 -04001938 struct nfsd4_conn *c;
J. Bruce Fields21b75b02010-10-26 10:07:17 -04001939 int ret;
J. Bruce Fields328ead22010-09-29 16:11:06 -04001940
1941 spin_lock(&clp->cl_lock);
J. Bruce Fieldsa663bdd2010-10-21 17:17:31 -04001942 c = __nfsd4_find_conn(new->cn_xprt, ses);
J. Bruce Fields328ead22010-09-29 16:11:06 -04001943 if (c) {
1944 spin_unlock(&clp->cl_lock);
1945 free_conn(new);
1946 return;
1947 }
1948 __nfsd4_hash_conn(new, ses);
1949 spin_unlock(&clp->cl_lock);
J. Bruce Fields21b75b02010-10-26 10:07:17 -04001950 ret = nfsd4_register_conn(new);
1951 if (ret)
1952 /* oops; xprt is already down: */
1953 nfsd4_conn_lost(&new->cn_xpt_user);
J. Bruce Fields328ead22010-09-29 16:11:06 -04001954 return;
1955}
1956
Mi Jinlong868b89c2011-04-27 09:09:58 +08001957static bool nfsd4_session_too_many_ops(struct svc_rqst *rqstp, struct nfsd4_session *session)
1958{
1959 struct nfsd4_compoundargs *args = rqstp->rq_argp;
1960
1961 return args->opcnt > session->se_fchannel.maxops;
1962}
1963
Mi Jinlongae82a8d2011-07-14 14:56:02 +08001964static bool nfsd4_request_too_big(struct svc_rqst *rqstp,
1965 struct nfsd4_session *session)
1966{
1967 struct xdr_buf *xb = &rqstp->rq_arg;
1968
1969 return xb->len > session->se_fchannel.maxreq_sz;
1970}
1971
Andy Adamson069b6ad2009-04-03 08:27:58 +03001972__be32
Benny Halevyb85d4c02009-04-03 08:28:08 +03001973nfsd4_sequence(struct svc_rqst *rqstp,
Andy Adamson069b6ad2009-04-03 08:27:58 +03001974 struct nfsd4_compound_state *cstate,
1975 struct nfsd4_sequence *seq)
1976{
Andy Adamsonf9bb94c42009-04-03 08:28:12 +03001977 struct nfsd4_compoundres *resp = rqstp->rq_resp;
Benny Halevyb85d4c02009-04-03 08:28:08 +03001978 struct nfsd4_session *session;
1979 struct nfsd4_slot *slot;
J. Bruce Fieldsa663bdd2010-10-21 17:17:31 -04001980 struct nfsd4_conn *conn;
J. Bruce Fields57b7b432012-04-25 17:58:50 -04001981 __be32 status;
Benny Halevyb85d4c02009-04-03 08:28:08 +03001982
Andy Adamsonf9bb94c42009-04-03 08:28:12 +03001983 if (resp->opcnt != 1)
1984 return nfserr_sequence_pos;
1985
J. Bruce Fieldsa663bdd2010-10-21 17:17:31 -04001986 /*
1987 * Will be either used or freed by nfsd4_sequence_check_conn
1988 * below.
1989 */
1990 conn = alloc_conn(rqstp, NFS4_CDFC4_FORE);
1991 if (!conn)
1992 return nfserr_jukebox;
1993
Benny Halevy9089f1b2010-05-12 00:12:26 +03001994 spin_lock(&client_lock);
Benny Halevyb85d4c02009-04-03 08:28:08 +03001995 status = nfserr_badsession;
1996 session = find_in_sessionid_hashtbl(&seq->sessionid);
1997 if (!session)
1998 goto out;
1999
Mi Jinlong868b89c2011-04-27 09:09:58 +08002000 status = nfserr_too_many_ops;
2001 if (nfsd4_session_too_many_ops(rqstp, session))
2002 goto out;
2003
Mi Jinlongae82a8d2011-07-14 14:56:02 +08002004 status = nfserr_req_too_big;
2005 if (nfsd4_request_too_big(rqstp, session))
2006 goto out;
2007
Benny Halevyb85d4c02009-04-03 08:28:08 +03002008 status = nfserr_badslot;
Alexandros Batsakis6c18ba92009-06-16 04:19:13 +03002009 if (seq->slotid >= session->se_fchannel.maxreqs)
Benny Halevyb85d4c02009-04-03 08:28:08 +03002010 goto out;
2011
Andy Adamson557ce262009-08-28 08:45:04 -04002012 slot = session->se_slots[seq->slotid];
Benny Halevyb85d4c02009-04-03 08:28:08 +03002013 dprintk("%s: slotid %d\n", __func__, seq->slotid);
2014
Andy Adamsona8dfdae2009-08-28 08:45:02 -04002015 /* We do not negotiate the number of slots yet, so set the
2016 * maxslots to the session maxreqs which is used to encode
2017 * sr_highest_slotid and the sr_target_slot id to maxslots */
2018 seq->maxslots = session->se_fchannel.maxreqs;
2019
J. Bruce Fields73e79482012-02-13 16:39:00 -05002020 status = check_slot_seqid(seq->seqid, slot->sl_seqid,
2021 slot->sl_flags & NFSD4_SLOT_INUSE);
Benny Halevyb85d4c02009-04-03 08:28:08 +03002022 if (status == nfserr_replay_cache) {
J. Bruce Fieldsbf5c43c2012-02-13 16:56:19 -05002023 status = nfserr_seq_misordered;
2024 if (!(slot->sl_flags & NFSD4_SLOT_INITIALIZED))
2025 goto out;
Benny Halevyb85d4c02009-04-03 08:28:08 +03002026 cstate->slot = slot;
2027 cstate->session = session;
Andy Adamsonda3846a2009-04-03 08:28:22 +03002028 /* Return the cached reply status and set cstate->status
Andy Adamson557ce262009-08-28 08:45:04 -04002029 * for nfsd4_proc_compound processing */
Andy Adamsonbf864a32009-04-03 08:28:35 +03002030 status = nfsd4_replay_cache_entry(resp, seq);
Andy Adamsonda3846a2009-04-03 08:28:22 +03002031 cstate->status = nfserr_replay_cache;
Benny Halevyaaf84eb2009-08-20 03:21:56 +03002032 goto out;
Benny Halevyb85d4c02009-04-03 08:28:08 +03002033 }
2034 if (status)
2035 goto out;
2036
J. Bruce Fieldsa663bdd2010-10-21 17:17:31 -04002037 nfsd4_sequence_check_conn(conn, session);
2038 conn = NULL;
J. Bruce Fields328ead22010-09-29 16:11:06 -04002039
Benny Halevyb85d4c02009-04-03 08:28:08 +03002040 /* Success! bump slot seqid */
Benny Halevyb85d4c02009-04-03 08:28:08 +03002041 slot->sl_seqid = seq->seqid;
J. Bruce Fieldsbf5c43c2012-02-13 16:56:19 -05002042 slot->sl_flags |= NFSD4_SLOT_INUSE;
J. Bruce Fields73e79482012-02-13 16:39:00 -05002043 if (seq->cachethis)
2044 slot->sl_flags |= NFSD4_SLOT_CACHETHIS;
J. Bruce Fieldsbf5c43c2012-02-13 16:56:19 -05002045 else
2046 slot->sl_flags &= ~NFSD4_SLOT_CACHETHIS;
Benny Halevyb85d4c02009-04-03 08:28:08 +03002047
2048 cstate->slot = slot;
2049 cstate->session = session;
2050
Benny Halevyb85d4c02009-04-03 08:28:08 +03002051out:
J. Bruce Fields26c0c752010-04-24 15:35:43 -04002052 /* Hold a session reference until done processing the compound. */
Benny Halevyaaf84eb2009-08-20 03:21:56 +03002053 if (cstate->session) {
J. Bruce Fields0d7bb712010-11-18 08:30:33 -05002054 struct nfs4_client *clp = session->se_client;
2055
Benny Halevy36acb662010-05-12 00:13:04 +03002056 nfsd4_get_session(cstate->session);
J. Bruce Fields0d7bb712010-11-18 08:30:33 -05002057 atomic_inc(&clp->cl_refcount);
Benny Halevy54237322011-10-19 19:12:58 -07002058 switch (clp->cl_cb_state) {
2059 case NFSD4_CB_DOWN:
Benny Halevyfc0c3dd2011-10-19 19:13:06 -07002060 seq->status_flags = SEQ4_STATUS_CB_PATH_DOWN;
Benny Halevy54237322011-10-19 19:12:58 -07002061 break;
2062 case NFSD4_CB_FAULT:
Benny Halevyfc0c3dd2011-10-19 19:13:06 -07002063 seq->status_flags = SEQ4_STATUS_BACKCHANNEL_FAULT;
Benny Halevy54237322011-10-19 19:12:58 -07002064 break;
Benny Halevyfc0c3dd2011-10-19 19:13:06 -07002065 default:
2066 seq->status_flags = 0;
Benny Halevy54237322011-10-19 19:12:58 -07002067 }
Benny Halevyaaf84eb2009-08-20 03:21:56 +03002068 }
J. Bruce Fieldsa663bdd2010-10-21 17:17:31 -04002069 kfree(conn);
Benny Halevy36acb662010-05-12 00:13:04 +03002070 spin_unlock(&client_lock);
Benny Halevyb85d4c02009-04-03 08:28:08 +03002071 dprintk("%s: return %d\n", __func__, ntohl(status));
2072 return status;
Andy Adamson069b6ad2009-04-03 08:27:58 +03002073}
2074
Mi Jinlong345c2842011-10-20 17:51:39 +08002075static inline bool has_resources(struct nfs4_client *clp)
2076{
2077 return !list_empty(&clp->cl_openowners)
2078 || !list_empty(&clp->cl_delegations)
2079 || !list_empty(&clp->cl_sessions);
2080}
2081
2082__be32
2083nfsd4_destroy_clientid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_destroy_clientid *dc)
2084{
2085 struct nfs4_client *conf, *unconf, *clp;
J. Bruce Fields57b7b432012-04-25 17:58:50 -04002086 __be32 status = 0;
Mi Jinlong345c2842011-10-20 17:51:39 +08002087
2088 nfs4_lock_state();
2089 unconf = find_unconfirmed_client(&dc->clientid);
2090 conf = find_confirmed_client(&dc->clientid);
2091
2092 if (conf) {
2093 clp = conf;
2094
2095 if (!is_client_expired(conf) && has_resources(conf)) {
2096 status = nfserr_clientid_busy;
2097 goto out;
2098 }
2099
2100 /* rfc5661 18.50.3 */
2101 if (cstate->session && conf == cstate->session->se_client) {
2102 status = nfserr_clientid_busy;
2103 goto out;
2104 }
2105 } else if (unconf)
2106 clp = unconf;
2107 else {
2108 status = nfserr_stale_clientid;
2109 goto out;
2110 }
2111
2112 expire_client(clp);
2113out:
2114 nfs4_unlock_state();
2115 dprintk("%s return %d\n", __func__, ntohl(status));
2116 return status;
2117}
2118
Andy Adamson069b6ad2009-04-03 08:27:58 +03002119__be32
J. Bruce Fields4dc6ec02010-04-19 15:11:28 -04002120nfsd4_reclaim_complete(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_reclaim_complete *rc)
2121{
J. Bruce Fields57b7b432012-04-25 17:58:50 -04002122 __be32 status = 0;
Mi Jinlongbcecf1c2011-04-27 09:14:30 +08002123
J. Bruce Fields4dc6ec02010-04-19 15:11:28 -04002124 if (rc->rca_one_fs) {
2125 if (!cstate->current_fh.fh_dentry)
2126 return nfserr_nofilehandle;
2127 /*
2128 * We don't take advantage of the rca_one_fs case.
2129 * That's OK, it's optional, we can safely ignore it.
2130 */
2131 return nfs_ok;
2132 }
Mi Jinlongbcecf1c2011-04-27 09:14:30 +08002133
J. Bruce Fields4dc6ec02010-04-19 15:11:28 -04002134 nfs4_lock_state();
Mi Jinlongbcecf1c2011-04-27 09:14:30 +08002135 status = nfserr_complete_already;
Jeff Laytona52d7262012-03-21 09:52:02 -04002136 if (test_and_set_bit(NFSD4_CLIENT_RECLAIM_COMPLETE,
2137 &cstate->session->se_client->cl_flags))
Mi Jinlongbcecf1c2011-04-27 09:14:30 +08002138 goto out;
2139
2140 status = nfserr_stale_clientid;
2141 if (is_client_expired(cstate->session->se_client))
J. Bruce Fields4dc6ec02010-04-19 15:11:28 -04002142 /*
2143 * The following error isn't really legal.
2144 * But we only get here if the client just explicitly
2145 * destroyed the client. Surely it no longer cares what
2146 * error it gets back on an operation for the dead
2147 * client.
2148 */
Mi Jinlongbcecf1c2011-04-27 09:14:30 +08002149 goto out;
2150
2151 status = nfs_ok;
Jeff Layton2a4317c2012-03-21 16:42:43 -04002152 nfsd4_client_record_create(cstate->session->se_client);
Mi Jinlongbcecf1c2011-04-27 09:14:30 +08002153out:
J. Bruce Fields4dc6ec02010-04-19 15:11:28 -04002154 nfs4_unlock_state();
Mi Jinlongbcecf1c2011-04-27 09:14:30 +08002155 return status;
J. Bruce Fields4dc6ec02010-04-19 15:11:28 -04002156}
2157
2158__be32
J.Bruce Fieldsb5914802006-12-13 00:35:38 -08002159nfsd4_setclientid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
2160 struct nfsd4_setclientid *setclid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002161{
J. Bruce Fieldsa084daf2011-10-10 15:07:40 -04002162 struct xdr_netobj clname = setclid->se_name;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002163 nfs4_verifier clverifier = setclid->se_verf;
2164 unsigned int strhashval;
NeilBrown28ce6052005-06-23 22:03:56 -07002165 struct nfs4_client *conf, *unconf, *new;
Al Virob37ad282006-10-19 23:28:59 -07002166 __be32 status;
NeilBrowna55370a2005-06-23 22:03:52 -07002167 char dname[HEXDIR_LEN];
Linus Torvalds1da177e2005-04-16 15:20:36 -07002168
NeilBrowna55370a2005-06-23 22:03:52 -07002169 status = nfs4_make_rec_clidname(dname, &clname);
2170 if (status)
Neil Brown73aea4e2005-09-13 01:25:39 -07002171 return status;
NeilBrowna55370a2005-06-23 22:03:52 -07002172
NeilBrowna55370a2005-06-23 22:03:52 -07002173 strhashval = clientstr_hashval(dname);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002174
J. Bruce Fields63db4632012-05-18 21:54:19 -04002175 /* Cases below refer to rfc 3530 section 14.2.33: */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002176 nfs4_lock_state();
J. Bruce Fieldse203d502010-11-24 17:30:54 -05002177 conf = find_confirmed_client_by_str(dname, strhashval);
NeilBrown28ce6052005-06-23 22:03:56 -07002178 if (conf) {
J. Bruce Fields63db4632012-05-18 21:54:19 -04002179 /* case 0: */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002180 status = nfserr_clid_inuse;
J. Bruce Fieldse203d502010-11-24 17:30:54 -05002181 if (clp_used_exchangeid(conf))
2182 goto out;
J. Bruce Fields026722c2009-03-18 15:06:26 -04002183 if (!same_creds(&conf->cl_cred, &rqstp->rq_cred)) {
Jeff Layton363168b2009-08-14 12:57:56 -04002184 char addr_str[INET6_ADDRSTRLEN];
2185 rpc_ntop((struct sockaddr *) &conf->cl_addr, addr_str,
2186 sizeof(addr_str));
2187 dprintk("NFSD: setclientid: string in use by client "
2188 "at %s\n", addr_str);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002189 goto out;
2190 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002191 }
J. Bruce Fieldse203d502010-11-24 17:30:54 -05002192 unconf = find_unconfirmed_client_by_str(dname, strhashval);
J. Bruce Fields8f930712012-05-18 22:06:41 -04002193 if (unconf)
2194 expire_client(unconf);
J. Bruce Fields3e772462011-08-10 19:07:33 -04002195 status = nfserr_jukebox;
J. Bruce Fields8f930712012-05-18 22:06:41 -04002196 new = create_client(clname, dname, rqstp, &clverifier);
2197 if (new == NULL)
2198 goto out;
J. Bruce Fields34b232b2012-05-18 22:23:42 -04002199 if (conf && same_verf(&conf->cl_verifier, &clverifier))
J. Bruce Fields63db4632012-05-18 21:54:19 -04002200 /* case 1: probable callback update */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002201 copy_clid(new, conf);
J. Bruce Fields34b232b2012-05-18 22:23:42 -04002202 else /* case 4 (new client) or cases 2, 3 (client reboot): */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002203 gen_clid(new);
J. Bruce Fields8323c3b2010-10-19 19:36:51 -04002204 /*
2205 * XXX: we should probably set this at creation time, and check
2206 * for consistent minorversion use throughout:
2207 */
2208 new->cl_minorversion = 0;
Takuma Umeya6f3d7722010-12-15 14:09:01 +09002209 gen_callback(new, setclid, rqstp);
J. Bruce Fieldsc175b832007-08-09 18:34:32 -04002210 add_to_unconfirmed(new, strhashval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002211 setclid->se_clientid.cl_boot = new->cl_clientid.cl_boot;
2212 setclid->se_clientid.cl_id = new->cl_clientid.cl_id;
2213 memcpy(setclid->se_confirm.data, new->cl_confirm.data, sizeof(setclid->se_confirm.data));
2214 status = nfs_ok;
2215out:
2216 nfs4_unlock_state();
2217 return status;
2218}
2219
2220
Al Virob37ad282006-10-19 23:28:59 -07002221__be32
J.Bruce Fieldsb5914802006-12-13 00:35:38 -08002222nfsd4_setclientid_confirm(struct svc_rqst *rqstp,
2223 struct nfsd4_compound_state *cstate,
2224 struct nfsd4_setclientid_confirm *setclientid_confirm)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002225{
NeilBrown21ab45a2005-06-23 22:04:14 -07002226 struct nfs4_client *conf, *unconf;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002227 nfs4_verifier confirm = setclientid_confirm->sc_confirm;
2228 clientid_t * clid = &setclientid_confirm->sc_clientid;
Al Virob37ad282006-10-19 23:28:59 -07002229 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002230
2231 if (STALE_CLIENTID(clid))
2232 return nfserr_stale_clientid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002233 nfs4_lock_state();
NeilBrown21ab45a2005-06-23 22:04:14 -07002234
2235 conf = find_confirmed_client(clid);
2236 unconf = find_unconfirmed_client(clid);
J. Bruce Fields8695b902012-05-19 10:05:58 -04002237 /*
2238 * We try hard to give out unique clientid's, so if we get an
2239 * attempt to confirm the same clientid with a different cred,
2240 * there's a bug somewhere. Let's charitably assume it's our
2241 * bug.
2242 */
2243 status = nfserr_serverfault;
2244 if (unconf && !same_creds(&unconf->cl_cred, &rqstp->rq_cred))
2245 goto out;
2246 if (conf && !same_creds(&conf->cl_cred, &rqstp->rq_cred))
2247 goto out;
J. Bruce Fields63db4632012-05-18 21:54:19 -04002248 /* cases below refer to rfc 3530 section 14.2.34: */
J. Bruce Fields90d700b2012-05-19 13:55:22 -04002249 if (!unconf || !same_verf(&confirm, &unconf->cl_confirm)) {
2250 if (conf && !unconf) /* case 2: probable retransmit */
2251 status = nfs_ok;
2252 else /* case 4: client hasn't noticed we rebooted yet? */
2253 status = nfserr_stale_clientid;
2254 goto out;
2255 }
2256 status = nfs_ok;
2257 if (conf) { /* case 1: callback update */
J. Bruce Fields8695b902012-05-19 10:05:58 -04002258 nfsd4_change_callback(conf, &unconf->cl_cb_conn);
2259 nfsd4_probe_callback(conf);
2260 expire_client(unconf);
J. Bruce Fields90d700b2012-05-19 13:55:22 -04002261 } else { /* case 3: normal case; new or rebooted client */
J. Bruce Fields8695b902012-05-19 10:05:58 -04002262 unsigned int hash = clientstr_hashval(unconf->cl_recdir);
J. Bruce Fields90d700b2012-05-19 13:55:22 -04002263
J. Bruce Fields8695b902012-05-19 10:05:58 -04002264 conf = find_confirmed_client_by_str(unconf->cl_recdir, hash);
2265 if (conf) {
2266 nfsd4_client_record_remove(conf);
2267 expire_client(conf);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002268 }
J. Bruce Fields8695b902012-05-19 10:05:58 -04002269 move_to_confirmed(unconf);
J. Bruce Fieldsf3d03b92012-05-23 11:38:38 -04002270 nfsd4_probe_callback(unconf);
NeilBrown08e89872005-06-23 22:04:11 -07002271 }
J. Bruce Fields8695b902012-05-19 10:05:58 -04002272out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002273 nfs4_unlock_state();
2274 return status;
2275}
2276
J. Bruce Fields32513b42011-10-13 16:00:16 -04002277static struct nfs4_file *nfsd4_alloc_file(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002278{
J. Bruce Fields32513b42011-10-13 16:00:16 -04002279 return kmem_cache_alloc(file_slab, GFP_KERNEL);
2280}
2281
2282/* OPEN Share state helper functions */
2283static void nfsd4_init_file(struct nfs4_file *fp, struct inode *ino)
2284{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002285 unsigned int hashval = file_hashval(ino);
2286
J. Bruce Fields32513b42011-10-13 16:00:16 -04002287 atomic_set(&fp->fi_ref, 1);
2288 INIT_LIST_HEAD(&fp->fi_hash);
2289 INIT_LIST_HEAD(&fp->fi_stateids);
2290 INIT_LIST_HEAD(&fp->fi_delegations);
2291 fp->fi_inode = igrab(ino);
2292 fp->fi_had_conflict = false;
2293 fp->fi_lease = NULL;
2294 memset(fp->fi_fds, 0, sizeof(fp->fi_fds));
2295 memset(fp->fi_access, 0, sizeof(fp->fi_access));
2296 spin_lock(&recall_lock);
2297 list_add(&fp->fi_hash, &file_hashtbl[hashval]);
2298 spin_unlock(&recall_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002299}
2300
2301static void
Christoph Lametere18b8902006-12-06 20:33:20 -08002302nfsd4_free_slab(struct kmem_cache **slab)
NeilBrowne60d4392005-06-23 22:03:01 -07002303{
NeilBrowne60d4392005-06-23 22:03:01 -07002304 if (*slab == NULL)
2305 return;
Alexey Dobriyan1a1d92c2006-09-27 01:49:40 -07002306 kmem_cache_destroy(*slab);
NeilBrowne60d4392005-06-23 22:03:01 -07002307 *slab = NULL;
NeilBrowne60d4392005-06-23 22:03:01 -07002308}
2309
J. Bruce Fieldse8ff2a82007-08-01 15:30:59 -04002310void
NeilBrowne60d4392005-06-23 22:03:01 -07002311nfsd4_free_slabs(void)
2312{
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002313 nfsd4_free_slab(&openowner_slab);
2314 nfsd4_free_slab(&lockowner_slab);
NeilBrowne60d4392005-06-23 22:03:01 -07002315 nfsd4_free_slab(&file_slab);
NeilBrown5ac049a2005-06-23 22:03:03 -07002316 nfsd4_free_slab(&stateid_slab);
NeilBrown5b2d21c2005-06-23 22:03:04 -07002317 nfsd4_free_slab(&deleg_slab);
NeilBrowne60d4392005-06-23 22:03:01 -07002318}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002319
Bryan Schumaker72083392011-11-01 15:24:59 -04002320int
Linus Torvalds1da177e2005-04-16 15:20:36 -07002321nfsd4_init_slabs(void)
2322{
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002323 openowner_slab = kmem_cache_create("nfsd4_openowners",
2324 sizeof(struct nfs4_openowner), 0, 0, NULL);
2325 if (openowner_slab == NULL)
2326 goto out_nomem;
2327 lockowner_slab = kmem_cache_create("nfsd4_lockowners",
2328 sizeof(struct nfs4_openowner), 0, 0, NULL);
2329 if (lockowner_slab == NULL)
NeilBrowne60d4392005-06-23 22:03:01 -07002330 goto out_nomem;
2331 file_slab = kmem_cache_create("nfsd4_files",
Paul Mundt20c2df82007-07-20 10:11:58 +09002332 sizeof(struct nfs4_file), 0, 0, NULL);
NeilBrowne60d4392005-06-23 22:03:01 -07002333 if (file_slab == NULL)
2334 goto out_nomem;
NeilBrown5ac049a2005-06-23 22:03:03 -07002335 stateid_slab = kmem_cache_create("nfsd4_stateids",
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04002336 sizeof(struct nfs4_ol_stateid), 0, 0, NULL);
NeilBrown5ac049a2005-06-23 22:03:03 -07002337 if (stateid_slab == NULL)
2338 goto out_nomem;
NeilBrown5b2d21c2005-06-23 22:03:04 -07002339 deleg_slab = kmem_cache_create("nfsd4_delegations",
Paul Mundt20c2df82007-07-20 10:11:58 +09002340 sizeof(struct nfs4_delegation), 0, 0, NULL);
NeilBrown5b2d21c2005-06-23 22:03:04 -07002341 if (deleg_slab == NULL)
2342 goto out_nomem;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002343 return 0;
NeilBrowne60d4392005-06-23 22:03:01 -07002344out_nomem:
2345 nfsd4_free_slabs();
2346 dprintk("nfsd4: out of memory while initializing nfsv4\n");
2347 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002348}
2349
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002350void nfs4_free_openowner(struct nfs4_openowner *oo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002351{
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002352 kfree(oo->oo_owner.so_owner.data);
2353 kmem_cache_free(openowner_slab, oo);
2354}
2355
2356void nfs4_free_lockowner(struct nfs4_lockowner *lo)
2357{
2358 kfree(lo->lo_owner.so_owner.data);
2359 kmem_cache_free(lockowner_slab, lo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002360}
2361
J. Bruce Fieldsff194bd2011-08-12 09:42:57 -04002362static void init_nfs4_replay(struct nfs4_replay *rp)
2363{
2364 rp->rp_status = nfserr_serverfault;
2365 rp->rp_buflen = 0;
2366 rp->rp_buf = rp->rp_ibuf;
2367}
2368
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002369static inline void *alloc_stateowner(struct kmem_cache *slab, struct xdr_netobj *owner, struct nfs4_client *clp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002370{
2371 struct nfs4_stateowner *sop;
2372
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002373 sop = kmem_cache_alloc(slab, GFP_KERNEL);
J. Bruce Fieldsff194bd2011-08-12 09:42:57 -04002374 if (!sop)
2375 return NULL;
2376
2377 sop->so_owner.data = kmemdup(owner->data, owner->len, GFP_KERNEL);
2378 if (!sop->so_owner.data) {
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002379 kmem_cache_free(slab, sop);
J. Bruce Fieldsff194bd2011-08-12 09:42:57 -04002380 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002381 }
J. Bruce Fieldsff194bd2011-08-12 09:42:57 -04002382 sop->so_owner.len = owner->len;
2383
J. Bruce Fieldsff194bd2011-08-12 09:42:57 -04002384 INIT_LIST_HEAD(&sop->so_stateids);
J. Bruce Fieldsff194bd2011-08-12 09:42:57 -04002385 sop->so_client = clp;
2386 init_nfs4_replay(&sop->so_replay);
2387 return sop;
2388}
2389
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002390static void hash_openowner(struct nfs4_openowner *oo, struct nfs4_client *clp, unsigned int strhashval)
J. Bruce Fieldsff194bd2011-08-12 09:42:57 -04002391{
J. Bruce Fields16bfdaaf2011-11-07 17:23:30 -05002392 list_add(&oo->oo_owner.so_strhash, &ownerstr_hashtbl[strhashval]);
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002393 list_add(&oo->oo_perclient, &clp->cl_openowners);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002394}
2395
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002396static struct nfs4_openowner *
Linus Torvalds1da177e2005-04-16 15:20:36 -07002397alloc_init_open_stateowner(unsigned int strhashval, struct nfs4_client *clp, struct nfsd4_open *open) {
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002398 struct nfs4_openowner *oo;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002399
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002400 oo = alloc_stateowner(openowner_slab, &open->op_owner, clp);
2401 if (!oo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002402 return NULL;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002403 oo->oo_owner.so_is_open_owner = 1;
2404 oo->oo_owner.so_seqid = open->op_seqid;
J. Bruce Fieldsd29b20c2011-10-13 15:12:59 -04002405 oo->oo_flags = NFS4_OO_NEW;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002406 oo->oo_time = 0;
J. Bruce Fields38c387b2011-09-16 17:42:48 -04002407 oo->oo_last_closed_stid = NULL;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002408 INIT_LIST_HEAD(&oo->oo_close_lru);
2409 hash_openowner(oo, clp, strhashval);
2410 return oo;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002411}
2412
J. Bruce Fields996e0932011-10-17 11:14:48 -04002413static 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 -04002414 struct nfs4_openowner *oo = open->op_openowner;
J. Bruce Fieldsd3b313a2011-09-15 15:02:41 -04002415 struct nfs4_client *clp = oo->oo_owner.so_client;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002416
J. Bruce Fields996e0932011-10-17 11:14:48 -04002417 init_stid(&stp->st_stid, clp, NFS4_OPEN_STID);
NeilBrownea1da632005-06-23 22:04:17 -07002418 INIT_LIST_HEAD(&stp->st_lockowners);
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002419 list_add(&stp->st_perstateowner, &oo->oo_owner.so_stateids);
NeilBrown8beefa22005-06-23 22:03:08 -07002420 list_add(&stp->st_perfile, &fp->fi_stateids);
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002421 stp->st_stateowner = &oo->oo_owner;
NeilBrown13cd2182005-06-23 22:03:10 -07002422 get_nfs4_file(fp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002423 stp->st_file = fp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002424 stp->st_access_bmap = 0;
2425 stp->st_deny_bmap = 0;
Jeff Layton82c5ff12012-05-11 09:45:13 -04002426 set_access(open->op_share_access, stp);
Jeff Laytonce0fc432012-05-11 09:45:14 -04002427 set_deny(open->op_share_deny, stp);
NeilBrown4c4cd222005-07-07 17:59:27 -07002428 stp->st_openstp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002429}
2430
2431static void
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002432move_to_close_lru(struct nfs4_openowner *oo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002433{
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002434 dprintk("NFSD: move_to_close_lru nfs4_openowner %p\n", oo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002435
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002436 list_move_tail(&oo->oo_close_lru, &close_lru);
2437 oo->oo_time = get_seconds();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002438}
2439
Linus Torvalds1da177e2005-04-16 15:20:36 -07002440static int
J. Bruce Fields599e0a22007-07-26 17:04:54 -04002441same_owner_str(struct nfs4_stateowner *sop, struct xdr_netobj *owner,
2442 clientid_t *clid)
2443{
2444 return (sop->so_owner.len == owner->len) &&
2445 0 == memcmp(sop->so_owner.data, owner->data, owner->len) &&
2446 (sop->so_client->cl_clientid.cl_id == clid->cl_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002447}
2448
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002449static struct nfs4_openowner *
Linus Torvalds1da177e2005-04-16 15:20:36 -07002450find_openstateowner_str(unsigned int hashval, struct nfsd4_open *open)
2451{
J. Bruce Fieldsa50d2ad2011-10-12 16:24:27 -04002452 struct nfs4_stateowner *so;
2453 struct nfs4_openowner *oo;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002454
J. Bruce Fields16bfdaaf2011-11-07 17:23:30 -05002455 list_for_each_entry(so, &ownerstr_hashtbl[hashval], so_strhash) {
2456 if (!so->so_is_open_owner)
2457 continue;
J. Bruce Fieldsa50d2ad2011-10-12 16:24:27 -04002458 if (same_owner_str(so, &open->op_owner, &open->op_clientid)) {
2459 oo = openowner(so);
2460 renew_client(oo->oo_owner.so_client);
2461 return oo;
2462 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002463 }
2464 return NULL;
2465}
2466
2467/* search file_hashtbl[] for file */
2468static struct nfs4_file *
2469find_file(struct inode *ino)
2470{
2471 unsigned int hashval = file_hashval(ino);
2472 struct nfs4_file *fp;
2473
J. Bruce Fields8b671b82009-02-22 14:51:34 -08002474 spin_lock(&recall_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002475 list_for_each_entry(fp, &file_hashtbl[hashval], fi_hash) {
NeilBrown13cd2182005-06-23 22:03:10 -07002476 if (fp->fi_inode == ino) {
2477 get_nfs4_file(fp);
J. Bruce Fields8b671b82009-02-22 14:51:34 -08002478 spin_unlock(&recall_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002479 return fp;
NeilBrown13cd2182005-06-23 22:03:10 -07002480 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002481 }
J. Bruce Fields8b671b82009-02-22 14:51:34 -08002482 spin_unlock(&recall_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002483 return NULL;
2484}
2485
J. Bruce Fields4f83aa32008-07-07 15:02:02 -04002486/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002487 * Called to check deny when READ with all zero stateid or
2488 * WRITE with all zero or all one stateid
2489 */
Al Virob37ad282006-10-19 23:28:59 -07002490static __be32
Linus Torvalds1da177e2005-04-16 15:20:36 -07002491nfs4_share_conflict(struct svc_fh *current_fh, unsigned int deny_type)
2492{
2493 struct inode *ino = current_fh->fh_dentry->d_inode;
2494 struct nfs4_file *fp;
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04002495 struct nfs4_ol_stateid *stp;
Al Virob37ad282006-10-19 23:28:59 -07002496 __be32 ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002497
2498 dprintk("NFSD: nfs4_share_conflict\n");
2499
2500 fp = find_file(ino);
NeilBrown13cd2182005-06-23 22:03:10 -07002501 if (!fp)
2502 return nfs_ok;
NeilBrownb7009492005-07-07 17:59:23 -07002503 ret = nfserr_locked;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002504 /* Search for conflicting share reservations */
NeilBrown13cd2182005-06-23 22:03:10 -07002505 list_for_each_entry(stp, &fp->fi_stateids, st_perfile) {
Jeff Laytonce0fc432012-05-11 09:45:14 -04002506 if (test_deny(deny_type, stp) ||
2507 test_deny(NFS4_SHARE_DENY_BOTH, stp))
NeilBrown13cd2182005-06-23 22:03:10 -07002508 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002509 }
NeilBrown13cd2182005-06-23 22:03:10 -07002510 ret = nfs_ok;
2511out:
2512 put_nfs4_file(fp);
2513 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002514}
2515
J. Bruce Fields6b57d9c2011-01-31 11:54:04 -05002516static void nfsd_break_one_deleg(struct nfs4_delegation *dp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002517{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002518 /* We're assuming the state code never drops its reference
2519 * without first removing the lease. Since we're in this lease
2520 * callback (and since the lease code is serialized by the kernel
2521 * lock) we know the server hasn't removed the lease yet, we know
2522 * it's safe to take a reference: */
2523 atomic_inc(&dp->dl_count);
2524
Linus Torvalds1da177e2005-04-16 15:20:36 -07002525 list_add_tail(&dp->dl_recall_lru, &del_recall_lru);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002526
Arnd Bergmann460781b2010-11-17 16:26:56 +01002527 /* only place dl_time is set. protected by lock_flocks*/
Linus Torvalds1da177e2005-04-16 15:20:36 -07002528 dp->dl_time = get_seconds();
2529
J. Bruce Fields6b57d9c2011-01-31 11:54:04 -05002530 nfsd4_cb_recall(dp);
2531}
2532
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05002533/* Called from break_lease() with lock_flocks() held. */
J. Bruce Fields6b57d9c2011-01-31 11:54:04 -05002534static void nfsd_break_deleg_cb(struct file_lock *fl)
2535{
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05002536 struct nfs4_file *fp = (struct nfs4_file *)fl->fl_owner;
2537 struct nfs4_delegation *dp;
J. Bruce Fields6b57d9c2011-01-31 11:54:04 -05002538
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05002539 BUG_ON(!fp);
2540 /* We assume break_lease is only called once per lease: */
2541 BUG_ON(fp->fi_had_conflict);
J. Bruce Fields0272e1f2007-09-12 18:56:12 -04002542 /*
2543 * We don't want the locks code to timeout the lease for us;
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05002544 * we'll remove it ourself if a delegation isn't returned
J. Bruce Fields6b57d9c2011-01-31 11:54:04 -05002545 * in time:
J. Bruce Fields0272e1f2007-09-12 18:56:12 -04002546 */
2547 fl->fl_break_time = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002548
J. Bruce Fields5d926e82011-02-07 16:53:46 -05002549 spin_lock(&recall_lock);
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05002550 fp->fi_had_conflict = true;
2551 list_for_each_entry(dp, &fp->fi_delegations, dl_perfile)
2552 nfsd_break_one_deleg(dp);
J. Bruce Fields5d926e82011-02-07 16:53:46 -05002553 spin_unlock(&recall_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002554}
2555
Linus Torvalds1da177e2005-04-16 15:20:36 -07002556static
2557int nfsd_change_deleg_cb(struct file_lock **onlist, int arg)
2558{
2559 if (arg & F_UNLCK)
2560 return lease_modify(onlist, arg);
2561 else
2562 return -EAGAIN;
2563}
2564
Alexey Dobriyan7b021962009-09-21 17:01:12 -07002565static const struct lock_manager_operations nfsd_lease_mng_ops = {
J. Bruce Fields8fb47a42011-07-20 20:21:59 -04002566 .lm_break = nfsd_break_deleg_cb,
2567 .lm_change = nfsd_change_deleg_cb,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002568};
2569
J. Bruce Fields7a8711c2011-09-02 09:03:37 -04002570static __be32 nfsd4_check_seqid(struct nfsd4_compound_state *cstate, struct nfs4_stateowner *so, u32 seqid)
2571{
2572 if (nfsd4_has_session(cstate))
2573 return nfs_ok;
2574 if (seqid == so->so_seqid - 1)
2575 return nfserr_replay_me;
2576 if (seqid == so->so_seqid)
2577 return nfs_ok;
2578 return nfserr_bad_seqid;
2579}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002580
Al Virob37ad282006-10-19 23:28:59 -07002581__be32
Andy Adamson66689582009-04-03 08:28:45 +03002582nfsd4_process_open1(struct nfsd4_compound_state *cstate,
2583 struct nfsd4_open *open)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002584{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002585 clientid_t *clientid = &open->op_clientid;
2586 struct nfs4_client *clp = NULL;
2587 unsigned int strhashval;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002588 struct nfs4_openowner *oo = NULL;
J. Bruce Fields4cdc9512011-10-17 15:57:47 -04002589 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002590
Linus Torvalds1da177e2005-04-16 15:20:36 -07002591 if (STALE_CLIENTID(&open->op_clientid))
2592 return nfserr_stale_clientid;
J. Bruce Fields32513b42011-10-13 16:00:16 -04002593 /*
2594 * In case we need it later, after we've already created the
2595 * file and don't want to risk a further failure:
2596 */
2597 open->op_file = nfsd4_alloc_file();
2598 if (open->op_file == NULL)
2599 return nfserr_jukebox;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002600
J. Bruce Fields16bfdaaf2011-11-07 17:23:30 -05002601 strhashval = ownerstr_hashval(clientid->cl_id, &open->op_owner);
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002602 oo = find_openstateowner_str(strhashval, open);
2603 open->op_openowner = oo;
2604 if (!oo) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002605 clp = find_confirmed_client(clientid);
2606 if (clp == NULL)
J. Bruce Fields0f442aa2006-01-18 17:43:34 -08002607 return nfserr_expired;
J. Bruce Fieldsbcf130f2011-10-12 20:44:20 -04002608 goto new_owner;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002609 }
J. Bruce Fieldsdad1c062011-09-12 12:24:13 -04002610 if (!(oo->oo_flags & NFS4_OO_CONFIRMED)) {
J. Bruce Fields0f442aa2006-01-18 17:43:34 -08002611 /* Replace unconfirmed owners without checking for replay. */
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002612 clp = oo->oo_owner.so_client;
2613 release_openowner(oo);
2614 open->op_openowner = NULL;
J. Bruce Fieldsbcf130f2011-10-12 20:44:20 -04002615 goto new_owner;
J. Bruce Fields0f442aa2006-01-18 17:43:34 -08002616 }
J. Bruce Fields4cdc9512011-10-17 15:57:47 -04002617 status = nfsd4_check_seqid(cstate, &oo->oo_owner, open->op_seqid);
2618 if (status)
2619 return status;
2620 clp = oo->oo_owner.so_client;
2621 goto alloc_stateid;
J. Bruce Fieldsbcf130f2011-10-12 20:44:20 -04002622new_owner:
2623 oo = alloc_init_open_stateowner(strhashval, clp, open);
2624 if (oo == NULL)
2625 return nfserr_jukebox;
2626 open->op_openowner = oo;
J. Bruce Fields4cdc9512011-10-17 15:57:47 -04002627alloc_stateid:
2628 open->op_stp = nfs4_alloc_stateid(clp);
2629 if (!open->op_stp)
2630 return nfserr_jukebox;
J. Bruce Fields0f442aa2006-01-18 17:43:34 -08002631 return nfs_ok;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002632}
2633
Al Virob37ad282006-10-19 23:28:59 -07002634static inline __be32
NeilBrown4a6e43e2005-06-23 22:02:50 -07002635nfs4_check_delegmode(struct nfs4_delegation *dp, int flags)
2636{
2637 if ((flags & WR_STATE) && (dp->dl_type == NFS4_OPEN_DELEGATE_READ))
2638 return nfserr_openmode;
2639 else
2640 return nfs_ok;
2641}
2642
Daniel Mackc47d8322011-05-16 16:38:14 +02002643static int share_access_to_flags(u32 share_access)
J. Bruce Fields24a01112010-05-18 20:01:35 -04002644{
J. Bruce Fields24a01112010-05-18 20:01:35 -04002645 return share_access == NFS4_SHARE_ACCESS_READ ? RD_STATE : WR_STATE;
2646}
2647
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04002648static struct nfs4_delegation *find_deleg_stateid(struct nfs4_client *cl, stateid_t *s)
J. Bruce Fieldsf459e452011-09-09 09:06:12 -04002649{
2650 struct nfs4_stid *ret;
2651
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04002652 ret = find_stateid_by_type(cl, s, NFS4_DELEG_STID);
J. Bruce Fieldsf459e452011-09-09 09:06:12 -04002653 if (!ret)
2654 return NULL;
2655 return delegstateid(ret);
2656}
2657
J. Bruce Fields8b289b22011-10-19 11:52:12 -04002658static bool nfsd4_is_deleg_cur(struct nfsd4_open *open)
2659{
2660 return open->op_claim_type == NFS4_OPEN_CLAIM_DELEGATE_CUR ||
2661 open->op_claim_type == NFS4_OPEN_CLAIM_DELEG_CUR_FH;
2662}
2663
Al Virob37ad282006-10-19 23:28:59 -07002664static __be32
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04002665nfs4_check_deleg(struct nfs4_client *cl, struct nfs4_file *fp, struct nfsd4_open *open,
NeilBrown567d9822005-06-23 22:02:53 -07002666 struct nfs4_delegation **dp)
2667{
2668 int flags;
Al Virob37ad282006-10-19 23:28:59 -07002669 __be32 status = nfserr_bad_stateid;
NeilBrown567d9822005-06-23 22:02:53 -07002670
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04002671 *dp = find_deleg_stateid(cl, &open->op_delegate_stateid);
NeilBrown567d9822005-06-23 22:02:53 -07002672 if (*dp == NULL)
NeilBrownc44c5ee2005-06-23 22:02:54 -07002673 goto out;
J. Bruce Fields24a01112010-05-18 20:01:35 -04002674 flags = share_access_to_flags(open->op_share_access);
NeilBrown567d9822005-06-23 22:02:53 -07002675 status = nfs4_check_delegmode(*dp, flags);
2676 if (status)
2677 *dp = NULL;
NeilBrownc44c5ee2005-06-23 22:02:54 -07002678out:
J. Bruce Fields8b289b22011-10-19 11:52:12 -04002679 if (!nfsd4_is_deleg_cur(open))
NeilBrownc44c5ee2005-06-23 22:02:54 -07002680 return nfs_ok;
2681 if (status)
2682 return status;
J. Bruce Fieldsdad1c062011-09-12 12:24:13 -04002683 open->op_openowner->oo_flags |= NFS4_OO_CONFIRMED;
NeilBrownc44c5ee2005-06-23 22:02:54 -07002684 return nfs_ok;
NeilBrown567d9822005-06-23 22:02:53 -07002685}
2686
Al Virob37ad282006-10-19 23:28:59 -07002687static __be32
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04002688nfs4_check_open(struct nfs4_file *fp, struct nfsd4_open *open, struct nfs4_ol_stateid **stpp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002689{
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04002690 struct nfs4_ol_stateid *local;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002691 struct nfs4_openowner *oo = open->op_openowner;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002692
NeilBrown8beefa22005-06-23 22:03:08 -07002693 list_for_each_entry(local, &fp->fi_stateids, st_perfile) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002694 /* ignore lock owners */
2695 if (local->st_stateowner->so_is_open_owner == 0)
2696 continue;
2697 /* remember if we have seen this open owner */
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002698 if (local->st_stateowner == &oo->oo_owner)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002699 *stpp = local;
2700 /* check for conflicting share reservations */
2701 if (!test_share(local, open))
J. Bruce Fields77eaae82011-09-02 12:08:20 -04002702 return nfserr_share_denied;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002703 }
J. Bruce Fields77eaae82011-09-02 12:08:20 -04002704 return nfs_ok;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002705}
2706
J. Bruce Fields996e0932011-10-17 11:14:48 -04002707static void nfs4_free_stateid(struct nfs4_ol_stateid *s)
2708{
2709 kmem_cache_free(stateid_slab, s);
NeilBrown5ac049a2005-06-23 22:03:03 -07002710}
2711
J. Bruce Fields21fb4012010-07-28 12:21:23 -04002712static inline int nfs4_access_to_access(u32 nfs4_access)
2713{
2714 int flags = 0;
2715
2716 if (nfs4_access & NFS4_SHARE_ACCESS_READ)
2717 flags |= NFSD_MAY_READ;
2718 if (nfs4_access & NFS4_SHARE_ACCESS_WRITE)
2719 flags |= NFSD_MAY_WRITE;
2720 return flags;
2721}
2722
Casey Bodley0c12eaf2011-07-23 14:58:10 -04002723static __be32 nfs4_get_vfs_file(struct svc_rqst *rqstp, struct nfs4_file *fp,
2724 struct svc_fh *cur_fh, struct nfsd4_open *open)
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04002725{
2726 __be32 status;
Casey Bodley0c12eaf2011-07-23 14:58:10 -04002727 int oflag = nfs4_access_to_omode(open->op_share_access);
2728 int access = nfs4_access_to_access(open->op_share_access);
2729
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04002730 if (!fp->fi_fds[oflag]) {
2731 status = nfsd_open(rqstp, cur_fh, S_IFREG, access,
2732 &fp->fi_fds[oflag]);
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04002733 if (status)
2734 return status;
2735 }
2736 nfs4_file_get_access(fp, oflag);
2737
2738 return nfs_ok;
2739}
2740
Al Virob37ad282006-10-19 23:28:59 -07002741static inline __be32
Linus Torvalds1da177e2005-04-16 15:20:36 -07002742nfsd4_truncate(struct svc_rqst *rqstp, struct svc_fh *fh,
2743 struct nfsd4_open *open)
2744{
2745 struct iattr iattr = {
2746 .ia_valid = ATTR_SIZE,
2747 .ia_size = 0,
2748 };
2749 if (!open->op_truncate)
2750 return 0;
2751 if (!(open->op_share_access & NFS4_SHARE_ACCESS_WRITE))
Al Viro92465852006-01-18 17:43:46 -08002752 return nfserr_inval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002753 return nfsd_setattr(rqstp, fh, &iattr, 0, (time_t)0);
2754}
2755
Al Virob37ad282006-10-19 23:28:59 -07002756static __be32
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04002757nfs4_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 -07002758{
J. Bruce Fieldsb6d2f1c2011-10-10 17:44:19 -04002759 u32 op_share_access = open->op_share_access;
J. Bruce Fields7d947842010-08-20 18:09:31 -04002760 bool new_access;
Al Virob37ad282006-10-19 23:28:59 -07002761 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002762
Jeff Layton82c5ff12012-05-11 09:45:13 -04002763 new_access = !test_access(op_share_access, stp);
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04002764 if (new_access) {
Casey Bodley0c12eaf2011-07-23 14:58:10 -04002765 status = nfs4_get_vfs_file(rqstp, fp, cur_fh, open);
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04002766 if (status)
2767 return status;
J. Bruce Fields6c26d082006-01-18 17:43:38 -08002768 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002769 status = nfsd4_truncate(rqstp, cur_fh, open);
2770 if (status) {
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04002771 if (new_access) {
J. Bruce Fieldsf197c272011-06-29 08:23:50 -04002772 int oflag = nfs4_access_to_omode(op_share_access);
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04002773 nfs4_file_put_access(fp, oflag);
2774 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002775 return status;
2776 }
2777 /* remember the open */
Jeff Layton82c5ff12012-05-11 09:45:13 -04002778 set_access(op_share_access, stp);
Jeff Laytonce0fc432012-05-11 09:45:14 -04002779 set_deny(open->op_share_deny, stp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002780
2781 return nfs_ok;
2782}
2783
2784
Linus Torvalds1da177e2005-04-16 15:20:36 -07002785static void
J. Bruce Fields1255a8f2012-03-06 14:35:16 -05002786nfs4_set_claim_prev(struct nfsd4_open *open, bool has_session)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002787{
J. Bruce Fieldsdad1c062011-09-12 12:24:13 -04002788 open->op_openowner->oo_flags |= NFS4_OO_CONFIRMED;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002789}
2790
J. Bruce Fields14a24e92010-12-10 19:02:49 -05002791/* Should we give out recallable state?: */
2792static bool nfsd4_cb_channel_good(struct nfs4_client *clp)
2793{
2794 if (clp->cl_cb_state == NFSD4_CB_UP)
2795 return true;
2796 /*
2797 * In the sessions case, since we don't have to establish a
2798 * separate connection for callbacks, we assume it's OK
2799 * until we hear otherwise:
2800 */
2801 return clp->cl_minorversion && clp->cl_cb_state == NFSD4_CB_UNKNOWN;
2802}
2803
J. Bruce Fields22d38c42011-01-31 11:55:12 -05002804static struct file_lock *nfs4_alloc_init_lease(struct nfs4_delegation *dp, int flag)
2805{
2806 struct file_lock *fl;
2807
2808 fl = locks_alloc_lock();
2809 if (!fl)
2810 return NULL;
2811 locks_init_lock(fl);
2812 fl->fl_lmops = &nfsd_lease_mng_ops;
2813 fl->fl_flags = FL_LEASE;
2814 fl->fl_type = flag == NFS4_OPEN_DELEGATE_READ? F_RDLCK: F_WRLCK;
2815 fl->fl_end = OFFSET_MAX;
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05002816 fl->fl_owner = (fl_owner_t)(dp->dl_file);
J. Bruce Fields22d38c42011-01-31 11:55:12 -05002817 fl->fl_pid = current->tgid;
J. Bruce Fields22d38c42011-01-31 11:55:12 -05002818 return fl;
2819}
2820
J. Bruce Fieldsedab9782011-01-31 17:58:10 -05002821static int nfs4_setlease(struct nfs4_delegation *dp, int flag)
2822{
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05002823 struct nfs4_file *fp = dp->dl_file;
J. Bruce Fieldsedab9782011-01-31 17:58:10 -05002824 struct file_lock *fl;
2825 int status;
2826
2827 fl = nfs4_alloc_init_lease(dp, flag);
2828 if (!fl)
2829 return -ENOMEM;
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05002830 fl->fl_file = find_readable_file(fp);
J. Bruce Fields2a74aba2011-09-23 17:20:02 -04002831 list_add(&dp->dl_perclnt, &dp->dl_stid.sc_client->cl_delegations);
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05002832 status = vfs_setlease(fl->fl_file, fl->fl_type, &fl);
J. Bruce Fieldsedab9782011-01-31 17:58:10 -05002833 if (status) {
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05002834 list_del_init(&dp->dl_perclnt);
J. Bruce Fieldsedab9782011-01-31 17:58:10 -05002835 locks_free_lock(fl);
2836 return -ENOMEM;
2837 }
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05002838 fp->fi_lease = fl;
2839 fp->fi_deleg_file = fl->fl_file;
2840 get_file(fp->fi_deleg_file);
2841 atomic_set(&fp->fi_delegees, 1);
2842 list_add(&dp->dl_perfile, &fp->fi_delegations);
2843 return 0;
2844}
2845
2846static int nfs4_set_delegation(struct nfs4_delegation *dp, int flag)
2847{
2848 struct nfs4_file *fp = dp->dl_file;
2849
2850 if (!fp->fi_lease)
2851 return nfs4_setlease(dp, flag);
2852 spin_lock(&recall_lock);
2853 if (fp->fi_had_conflict) {
2854 spin_unlock(&recall_lock);
2855 return -EAGAIN;
2856 }
2857 atomic_inc(&fp->fi_delegees);
2858 list_add(&dp->dl_perfile, &fp->fi_delegations);
2859 spin_unlock(&recall_lock);
J. Bruce Fields2a74aba2011-09-23 17:20:02 -04002860 list_add(&dp->dl_perclnt, &dp->dl_stid.sc_client->cl_delegations);
J. Bruce Fieldsedab9782011-01-31 17:58:10 -05002861 return 0;
2862}
2863
Benny Halevy4aa89132012-02-21 14:16:44 -08002864static void nfsd4_open_deleg_none_ext(struct nfsd4_open *open, int status)
2865{
2866 open->op_delegate_type = NFS4_OPEN_DELEGATE_NONE_EXT;
2867 if (status == -EAGAIN)
2868 open->op_why_no_deleg = WND4_CONTENTION;
2869 else {
2870 open->op_why_no_deleg = WND4_RESOURCE;
2871 switch (open->op_deleg_want) {
2872 case NFS4_SHARE_WANT_READ_DELEG:
2873 case NFS4_SHARE_WANT_WRITE_DELEG:
2874 case NFS4_SHARE_WANT_ANY_DELEG:
2875 break;
2876 case NFS4_SHARE_WANT_CANCEL:
2877 open->op_why_no_deleg = WND4_CANCELLED;
2878 break;
2879 case NFS4_SHARE_WANT_NO_DELEG:
2880 BUG(); /* not supposed to get here */
2881 }
2882 }
2883}
2884
Linus Torvalds1da177e2005-04-16 15:20:36 -07002885/*
2886 * Attempt to hand out a delegation.
2887 */
2888static void
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04002889nfs4_open_delegation(struct svc_fh *fh, struct nfsd4_open *open, struct nfs4_ol_stateid *stp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002890{
2891 struct nfs4_delegation *dp;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002892 struct nfs4_openowner *oo = container_of(stp->st_stateowner, struct nfs4_openowner, oo_owner);
J. Bruce Fields14a24e92010-12-10 19:02:49 -05002893 int cb_up;
Benny Halevyd24433c2012-02-16 20:57:17 +02002894 int status = 0, flag = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002895
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002896 cb_up = nfsd4_cb_channel_good(oo->oo_owner.so_client);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002897 flag = NFS4_OPEN_DELEGATE_NONE;
NeilBrown7b190fe2005-06-23 22:03:23 -07002898 open->op_recall = 0;
2899 switch (open->op_claim_type) {
2900 case NFS4_OPEN_CLAIM_PREVIOUS:
J. Bruce Fields2bf23872010-03-08 12:37:27 -05002901 if (!cb_up)
NeilBrown7b190fe2005-06-23 22:03:23 -07002902 open->op_recall = 1;
2903 flag = open->op_delegate_type;
2904 if (flag == NFS4_OPEN_DELEGATE_NONE)
2905 goto out;
2906 break;
2907 case NFS4_OPEN_CLAIM_NULL:
2908 /* Let's not give out any delegations till everyone's
2909 * had the chance to reclaim theirs.... */
J. Bruce Fieldsaf558e32007-09-06 12:34:25 -04002910 if (locks_in_grace())
NeilBrown7b190fe2005-06-23 22:03:23 -07002911 goto out;
J. Bruce Fieldsdad1c062011-09-12 12:24:13 -04002912 if (!cb_up || !(oo->oo_flags & NFS4_OO_CONFIRMED))
NeilBrown7b190fe2005-06-23 22:03:23 -07002913 goto out;
2914 if (open->op_share_access & NFS4_SHARE_ACCESS_WRITE)
2915 flag = NFS4_OPEN_DELEGATE_WRITE;
2916 else
2917 flag = NFS4_OPEN_DELEGATE_READ;
2918 break;
2919 default:
2920 goto out;
2921 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002922
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04002923 dp = alloc_init_deleg(oo->oo_owner.so_client, stp, fh, flag);
J. Bruce Fieldsdd239cc2011-01-31 17:14:55 -05002924 if (dp == NULL)
2925 goto out_no_deleg;
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05002926 status = nfs4_set_delegation(dp, flag);
J. Bruce Fieldsedab9782011-01-31 17:58:10 -05002927 if (status)
J. Bruce Fieldsdd239cc2011-01-31 17:14:55 -05002928 goto out_free;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002929
J. Bruce Fieldsd5477a82011-09-08 12:07:44 -04002930 memcpy(&open->op_delegate_stateid, &dp->dl_stid.sc_stateid, sizeof(dp->dl_stid.sc_stateid));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002931
Benny Halevy8c10cbd2009-10-19 12:04:53 +02002932 dprintk("NFSD: delegation stateid=" STATEID_FMT "\n",
J. Bruce Fieldsd5477a82011-09-08 12:07:44 -04002933 STATEID_VAL(&dp->dl_stid.sc_stateid));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002934out:
2935 open->op_delegate_type = flag;
Benny Halevyd24433c2012-02-16 20:57:17 +02002936 if (flag == NFS4_OPEN_DELEGATE_NONE) {
2937 if (open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS &&
2938 open->op_delegate_type != NFS4_OPEN_DELEGATE_NONE)
2939 dprintk("NFSD: WARNING: refusing delegation reclaim\n");
2940
Benny Halevy4aa89132012-02-21 14:16:44 -08002941 /* 4.1 client asking for a delegation? */
2942 if (open->op_deleg_want)
2943 nfsd4_open_deleg_none_ext(open, status);
Benny Halevyd24433c2012-02-16 20:57:17 +02002944 }
J. Bruce Fieldsdd239cc2011-01-31 17:14:55 -05002945 return;
2946out_free:
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05002947 nfs4_put_delegation(dp);
J. Bruce Fieldsdd239cc2011-01-31 17:14:55 -05002948out_no_deleg:
2949 flag = NFS4_OPEN_DELEGATE_NONE;
2950 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002951}
2952
Benny Halevye27f49c2012-02-21 14:16:54 -08002953static void nfsd4_deleg_xgrade_none_ext(struct nfsd4_open *open,
2954 struct nfs4_delegation *dp)
2955{
2956 if (open->op_deleg_want == NFS4_SHARE_WANT_READ_DELEG &&
2957 dp->dl_type == NFS4_OPEN_DELEGATE_WRITE) {
2958 open->op_delegate_type = NFS4_OPEN_DELEGATE_NONE_EXT;
2959 open->op_why_no_deleg = WND4_NOT_SUPP_DOWNGRADE;
2960 } else if (open->op_deleg_want == NFS4_SHARE_WANT_WRITE_DELEG &&
2961 dp->dl_type == NFS4_OPEN_DELEGATE_WRITE) {
2962 open->op_delegate_type = NFS4_OPEN_DELEGATE_NONE_EXT;
2963 open->op_why_no_deleg = WND4_NOT_SUPP_UPGRADE;
2964 }
2965 /* Otherwise the client must be confused wanting a delegation
2966 * it already has, therefore we don't return
2967 * NFS4_OPEN_DELEGATE_NONE_EXT and reason.
2968 */
2969}
2970
Linus Torvalds1da177e2005-04-16 15:20:36 -07002971/*
2972 * called with nfs4_lock_state() held.
2973 */
Al Virob37ad282006-10-19 23:28:59 -07002974__be32
Linus Torvalds1da177e2005-04-16 15:20:36 -07002975nfsd4_process_open2(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_open *open)
2976{
Andy Adamson66689582009-04-03 08:28:45 +03002977 struct nfsd4_compoundres *resp = rqstp->rq_resp;
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04002978 struct nfs4_client *cl = open->op_openowner->oo_owner.so_client;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002979 struct nfs4_file *fp = NULL;
2980 struct inode *ino = current_fh->fh_dentry->d_inode;
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04002981 struct nfs4_ol_stateid *stp = NULL;
NeilBrown567d9822005-06-23 22:02:53 -07002982 struct nfs4_delegation *dp = NULL;
Al Virob37ad282006-10-19 23:28:59 -07002983 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002984
Linus Torvalds1da177e2005-04-16 15:20:36 -07002985 /*
2986 * Lookup file; if found, lookup stateid and check open request,
2987 * and check for delegations in the process of being recalled.
2988 * If not found, create the nfs4_file struct
2989 */
2990 fp = find_file(ino);
2991 if (fp) {
2992 if ((status = nfs4_check_open(fp, open, &stp)))
2993 goto out;
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04002994 status = nfs4_check_deleg(cl, fp, open, &dp);
NeilBrownc44c5ee2005-06-23 22:02:54 -07002995 if (status)
2996 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002997 } else {
NeilBrownc44c5ee2005-06-23 22:02:54 -07002998 status = nfserr_bad_stateid;
J. Bruce Fields8b289b22011-10-19 11:52:12 -04002999 if (nfsd4_is_deleg_cur(open))
NeilBrownc44c5ee2005-06-23 22:02:54 -07003000 goto out;
J. Bruce Fields3e772462011-08-10 19:07:33 -04003001 status = nfserr_jukebox;
J. Bruce Fields32513b42011-10-13 16:00:16 -04003002 fp = open->op_file;
3003 open->op_file = NULL;
3004 nfsd4_init_file(fp, ino);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003005 }
3006
3007 /*
3008 * OPEN the file, or upgrade an existing OPEN.
3009 * If truncate fails, the OPEN fails.
3010 */
3011 if (stp) {
3012 /* Stateid was found, this is an OPEN upgrade */
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04003013 status = nfs4_upgrade_open(rqstp, fp, current_fh, stp, open);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003014 if (status)
3015 goto out;
3016 } else {
J. Bruce Fields4cdc9512011-10-17 15:57:47 -04003017 status = nfs4_get_vfs_file(rqstp, fp, current_fh, open);
NeilBrown567d9822005-06-23 22:02:53 -07003018 if (status)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003019 goto out;
J. Bruce Fields4cdc9512011-10-17 15:57:47 -04003020 stp = open->op_stp;
3021 open->op_stp = NULL;
J. Bruce Fields996e0932011-10-17 11:14:48 -04003022 init_open_stateid(stp, fp, open);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003023 status = nfsd4_truncate(rqstp, current_fh, open);
3024 if (status) {
J. Bruce Fields22839632009-01-11 14:27:17 -05003025 release_open_stateid(stp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003026 goto out;
3027 }
3028 }
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04003029 update_stateid(&stp->st_stid.sc_stateid);
3030 memcpy(&open->op_stateid, &stp->st_stid.sc_stateid, sizeof(stateid_t));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003031
Benny Halevyd24433c2012-02-16 20:57:17 +02003032 if (nfsd4_has_session(&resp->cstate)) {
J. Bruce Fieldsdad1c062011-09-12 12:24:13 -04003033 open->op_openowner->oo_flags |= NFS4_OO_CONFIRMED;
Andy Adamson66689582009-04-03 08:28:45 +03003034
Benny Halevyd24433c2012-02-16 20:57:17 +02003035 if (open->op_deleg_want & NFS4_SHARE_WANT_NO_DELEG) {
3036 open->op_delegate_type = NFS4_OPEN_DELEGATE_NONE_EXT;
3037 open->op_why_no_deleg = WND4_NOT_WANTED;
3038 goto nodeleg;
3039 }
3040 }
3041
Linus Torvalds1da177e2005-04-16 15:20:36 -07003042 /*
3043 * Attempt to hand out a delegation. No error return, because the
3044 * OPEN succeeds even if we fail.
3045 */
3046 nfs4_open_delegation(current_fh, open, stp);
Benny Halevyd24433c2012-02-16 20:57:17 +02003047nodeleg:
Linus Torvalds1da177e2005-04-16 15:20:36 -07003048 status = nfs_ok;
3049
Benny Halevy8c10cbd2009-10-19 12:04:53 +02003050 dprintk("%s: stateid=" STATEID_FMT "\n", __func__,
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04003051 STATEID_VAL(&stp->st_stid.sc_stateid));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003052out:
Benny Halevyd24433c2012-02-16 20:57:17 +02003053 /* 4.1 client trying to upgrade/downgrade delegation? */
3054 if (open->op_delegate_type == NFS4_OPEN_DELEGATE_NONE && dp &&
Benny Halevye27f49c2012-02-21 14:16:54 -08003055 open->op_deleg_want)
3056 nfsd4_deleg_xgrade_none_ext(open, dp);
Benny Halevyd24433c2012-02-16 20:57:17 +02003057
NeilBrown13cd2182005-06-23 22:03:10 -07003058 if (fp)
3059 put_nfs4_file(fp);
NeilBrown37515172005-07-07 17:59:16 -07003060 if (status == 0 && open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS)
J. Bruce Fields1255a8f2012-03-06 14:35:16 -05003061 nfs4_set_claim_prev(open, nfsd4_has_session(&resp->cstate));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003062 /*
3063 * To finish the open response, we just need to set the rflags.
3064 */
3065 open->op_rflags = NFS4_OPEN_RESULT_LOCKTYPE_POSIX;
J. Bruce Fieldsdad1c062011-09-12 12:24:13 -04003066 if (!(open->op_openowner->oo_flags & NFS4_OO_CONFIRMED) &&
Andy Adamson66689582009-04-03 08:28:45 +03003067 !nfsd4_has_session(&resp->cstate))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003068 open->op_rflags |= NFS4_OPEN_RESULT_CONFIRM;
3069
3070 return status;
3071}
3072
J. Bruce Fieldsd29b20c2011-10-13 15:12:59 -04003073void nfsd4_cleanup_open_state(struct nfsd4_open *open, __be32 status)
3074{
3075 if (open->op_openowner) {
3076 struct nfs4_openowner *oo = open->op_openowner;
3077
3078 if (!list_empty(&oo->oo_owner.so_stateids))
3079 list_del_init(&oo->oo_close_lru);
3080 if (oo->oo_flags & NFS4_OO_NEW) {
3081 if (status) {
3082 release_openowner(oo);
3083 open->op_openowner = NULL;
3084 } else
3085 oo->oo_flags &= ~NFS4_OO_NEW;
3086 }
3087 }
J. Bruce Fields32513b42011-10-13 16:00:16 -04003088 if (open->op_file)
3089 nfsd4_free_file(open->op_file);
J. Bruce Fields4cdc9512011-10-17 15:57:47 -04003090 if (open->op_stp)
3091 nfs4_free_stateid(open->op_stp);
J. Bruce Fieldsd29b20c2011-10-13 15:12:59 -04003092}
3093
Al Virob37ad282006-10-19 23:28:59 -07003094__be32
J.Bruce Fieldsb5914802006-12-13 00:35:38 -08003095nfsd4_renew(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
3096 clientid_t *clid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003097{
3098 struct nfs4_client *clp;
Al Virob37ad282006-10-19 23:28:59 -07003099 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003100
3101 nfs4_lock_state();
3102 dprintk("process_renew(%08x/%08x): starting\n",
3103 clid->cl_boot, clid->cl_id);
3104 status = nfserr_stale_clientid;
3105 if (STALE_CLIENTID(clid))
3106 goto out;
3107 clp = find_confirmed_client(clid);
3108 status = nfserr_expired;
3109 if (clp == NULL) {
3110 /* We assume the client took too long to RENEW. */
3111 dprintk("nfsd4_renew: clientid not found!\n");
3112 goto out;
3113 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003114 status = nfserr_cb_path_down;
NeilBrownea1da632005-06-23 22:04:17 -07003115 if (!list_empty(&clp->cl_delegations)
J. Bruce Fields77a35692010-04-30 18:51:44 -04003116 && clp->cl_cb_state != NFSD4_CB_UP)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003117 goto out;
3118 status = nfs_ok;
3119out:
3120 nfs4_unlock_state();
3121 return status;
3122}
3123
Daniel Mackc47d8322011-05-16 16:38:14 +02003124static struct lock_manager nfsd4_manager = {
J. Bruce Fieldsaf558e32007-09-06 12:34:25 -04003125};
3126
Jeff Layton33dcc482012-04-10 11:08:48 -04003127static bool grace_ended;
3128
NeilBrowna76b4312005-06-23 22:04:01 -07003129static void
J. Bruce Fieldsaf558e32007-09-06 12:34:25 -04003130nfsd4_end_grace(void)
NeilBrowna76b4312005-06-23 22:04:01 -07003131{
Jeff Layton33dcc482012-04-10 11:08:48 -04003132 /* do nothing if grace period already ended */
3133 if (grace_ended)
3134 return;
3135
NeilBrowna76b4312005-06-23 22:04:01 -07003136 dprintk("NFSD: end of grace period\n");
Jeff Layton33dcc482012-04-10 11:08:48 -04003137 grace_ended = true;
Jeff Layton2a4317c2012-03-21 16:42:43 -04003138 nfsd4_record_grace_done(&init_net, boot_time);
J. Bruce Fieldsaf558e32007-09-06 12:34:25 -04003139 locks_end_grace(&nfsd4_manager);
J. Bruce Fieldse46b4982010-03-01 19:21:21 -05003140 /*
3141 * Now that every NFSv4 client has had the chance to recover and
3142 * to see the (possibly new, possibly shorter) lease time, we
3143 * can safely set the next grace time to the current lease time:
3144 */
3145 nfsd4_grace = nfsd4_lease;
NeilBrowna76b4312005-06-23 22:04:01 -07003146}
3147
NeilBrownfd39ca92005-06-23 22:04:03 -07003148static time_t
Linus Torvalds1da177e2005-04-16 15:20:36 -07003149nfs4_laundromat(void)
3150{
3151 struct nfs4_client *clp;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003152 struct nfs4_openowner *oo;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003153 struct nfs4_delegation *dp;
3154 struct list_head *pos, *next, reaplist;
J. Bruce Fieldscf07d2e2010-02-28 23:20:19 -05003155 time_t cutoff = get_seconds() - nfsd4_lease;
3156 time_t t, clientid_val = nfsd4_lease;
3157 time_t u, test_val = nfsd4_lease;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003158
3159 nfs4_lock_state();
3160
3161 dprintk("NFSD: laundromat service - starting\n");
Jeff Layton33dcc482012-04-10 11:08:48 -04003162 nfsd4_end_grace();
Benny Halevy36acb662010-05-12 00:13:04 +03003163 INIT_LIST_HEAD(&reaplist);
3164 spin_lock(&client_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003165 list_for_each_safe(pos, next, &client_lru) {
3166 clp = list_entry(pos, struct nfs4_client, cl_lru);
3167 if (time_after((unsigned long)clp->cl_time, (unsigned long)cutoff)) {
3168 t = clp->cl_time - cutoff;
3169 if (clientid_val > t)
3170 clientid_val = t;
3171 break;
3172 }
Benny Halevyd7682982010-05-12 00:13:54 +03003173 if (atomic_read(&clp->cl_refcount)) {
3174 dprintk("NFSD: client in use (clientid %08x)\n",
3175 clp->cl_clientid.cl_id);
3176 continue;
3177 }
3178 unhash_client_locked(clp);
3179 list_add(&clp->cl_lru, &reaplist);
Benny Halevy36acb662010-05-12 00:13:04 +03003180 }
3181 spin_unlock(&client_lock);
3182 list_for_each_safe(pos, next, &reaplist) {
3183 clp = list_entry(pos, struct nfs4_client, cl_lru);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003184 dprintk("NFSD: purging unused client (clientid %08x)\n",
3185 clp->cl_clientid.cl_id);
Jeff Layton2a4317c2012-03-21 16:42:43 -04003186 nfsd4_client_record_remove(clp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003187 expire_client(clp);
3188 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003189 spin_lock(&recall_lock);
3190 list_for_each_safe(pos, next, &del_recall_lru) {
3191 dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
3192 if (time_after((unsigned long)dp->dl_time, (unsigned long)cutoff)) {
3193 u = dp->dl_time - cutoff;
3194 if (test_val > u)
3195 test_val = u;
3196 break;
3197 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003198 list_move(&dp->dl_recall_lru, &reaplist);
3199 }
3200 spin_unlock(&recall_lock);
3201 list_for_each_safe(pos, next, &reaplist) {
3202 dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003203 unhash_delegation(dp);
3204 }
J. Bruce Fieldscf07d2e2010-02-28 23:20:19 -05003205 test_val = nfsd4_lease;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003206 list_for_each_safe(pos, next, &close_lru) {
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003207 oo = container_of(pos, struct nfs4_openowner, oo_close_lru);
3208 if (time_after((unsigned long)oo->oo_time, (unsigned long)cutoff)) {
3209 u = oo->oo_time - cutoff;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003210 if (test_val > u)
3211 test_val = u;
3212 break;
3213 }
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003214 release_openowner(oo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003215 }
3216 if (clientid_val < NFSD_LAUNDROMAT_MINTIMEOUT)
3217 clientid_val = NFSD_LAUNDROMAT_MINTIMEOUT;
3218 nfs4_unlock_state();
3219 return clientid_val;
3220}
3221
Harvey Harrisona254b242008-02-20 12:49:00 -08003222static struct workqueue_struct *laundry_wq;
3223static void laundromat_main(struct work_struct *);
3224static DECLARE_DELAYED_WORK(laundromat_work, laundromat_main);
3225
3226static void
David Howellsc4028952006-11-22 14:57:56 +00003227laundromat_main(struct work_struct *not_used)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003228{
3229 time_t t;
3230
3231 t = nfs4_laundromat();
3232 dprintk("NFSD: laundromat_main - sleeping for %ld seconds\n", t);
NeilBrown58da2822005-06-23 22:03:19 -07003233 queue_delayed_work(laundry_wq, &laundromat_work, t*HZ);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003234}
3235
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -04003236static inline __be32 nfs4_check_fh(struct svc_fh *fhp, struct nfs4_ol_stateid *stp)
NeilBrownf8816512005-07-07 17:59:25 -07003237{
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -04003238 if (fhp->fh_dentry->d_inode != stp->st_file->fi_inode)
3239 return nfserr_bad_stateid;
3240 return nfs_ok;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003241}
3242
3243static int
3244STALE_STATEID(stateid_t *stateid)
3245{
J. Bruce Fieldsd3b313a2011-09-15 15:02:41 -04003246 if (stateid->si_opaque.so_clid.cl_boot == boot_time)
J. Bruce Fieldse4e83ea2010-04-22 16:21:39 -04003247 return 0;
3248 dprintk("NFSD: stale stateid " STATEID_FMT "!\n",
Benny Halevy8c10cbd2009-10-19 12:04:53 +02003249 STATEID_VAL(stateid));
J. Bruce Fieldse4e83ea2010-04-22 16:21:39 -04003250 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003251}
3252
3253static inline int
Jeff Layton82c5ff12012-05-11 09:45:13 -04003254access_permit_read(struct nfs4_ol_stateid *stp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003255{
Jeff Layton82c5ff12012-05-11 09:45:13 -04003256 return test_access(NFS4_SHARE_ACCESS_READ, stp) ||
3257 test_access(NFS4_SHARE_ACCESS_BOTH, stp) ||
3258 test_access(NFS4_SHARE_ACCESS_WRITE, stp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003259}
3260
3261static inline int
Jeff Layton82c5ff12012-05-11 09:45:13 -04003262access_permit_write(struct nfs4_ol_stateid *stp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003263{
Jeff Layton82c5ff12012-05-11 09:45:13 -04003264 return test_access(NFS4_SHARE_ACCESS_WRITE, stp) ||
3265 test_access(NFS4_SHARE_ACCESS_BOTH, stp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003266}
3267
3268static
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04003269__be32 nfs4_check_openmode(struct nfs4_ol_stateid *stp, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003270{
Al Virob37ad282006-10-19 23:28:59 -07003271 __be32 status = nfserr_openmode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003272
J. Bruce Fields02921912010-07-29 15:16:59 -04003273 /* For lock stateid's, we test the parent open, not the lock: */
3274 if (stp->st_openstp)
3275 stp = stp->st_openstp;
Jeff Layton82c5ff12012-05-11 09:45:13 -04003276 if ((flags & WR_STATE) && !access_permit_write(stp))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003277 goto out;
Jeff Layton82c5ff12012-05-11 09:45:13 -04003278 if ((flags & RD_STATE) && !access_permit_read(stp))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003279 goto out;
3280 status = nfs_ok;
3281out:
3282 return status;
3283}
3284
Al Virob37ad282006-10-19 23:28:59 -07003285static inline __be32
Linus Torvalds1da177e2005-04-16 15:20:36 -07003286check_special_stateids(svc_fh *current_fh, stateid_t *stateid, int flags)
3287{
J. Bruce Fields203a8c82009-02-21 13:29:14 -08003288 if (ONE_STATEID(stateid) && (flags & RD_STATE))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003289 return nfs_ok;
J. Bruce Fieldsaf558e32007-09-06 12:34:25 -04003290 else if (locks_in_grace()) {
Lucas De Marchi25985ed2011-03-30 22:57:33 -03003291 /* Answer in remaining cases depends on existence of
Linus Torvalds1da177e2005-04-16 15:20:36 -07003292 * conflicting state; so we must wait out the grace period. */
3293 return nfserr_grace;
3294 } else if (flags & WR_STATE)
3295 return nfs4_share_conflict(current_fh,
3296 NFS4_SHARE_DENY_WRITE);
3297 else /* (flags & RD_STATE) && ZERO_STATEID(stateid) */
3298 return nfs4_share_conflict(current_fh,
3299 NFS4_SHARE_DENY_READ);
3300}
3301
3302/*
3303 * Allow READ/WRITE during grace period on recovered state only for files
3304 * that are not able to provide mandatory locking.
3305 */
3306static inline int
J. Bruce Fields18f82732009-02-21 15:23:01 -08003307grace_disallows_io(struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003308{
J. Bruce Fields203a8c82009-02-21 13:29:14 -08003309 return locks_in_grace() && mandatory_lock(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003310}
3311
J. Bruce Fields81b82962011-08-23 11:03:29 -04003312/* Returns true iff a is later than b: */
3313static bool stateid_generation_after(stateid_t *a, stateid_t *b)
3314{
3315 return (s32)a->si_generation - (s32)b->si_generation > 0;
3316}
3317
J. Bruce Fields57b7b432012-04-25 17:58:50 -04003318static __be32 check_stateid_generation(stateid_t *in, stateid_t *ref, bool has_session)
J. Bruce Fields0836f582008-01-26 19:08:12 -05003319{
Andy Adamson66689582009-04-03 08:28:45 +03003320 /*
3321 * When sessions are used the stateid generation number is ignored
3322 * when it is zero.
3323 */
J. Bruce Fields28dde242011-08-22 10:07:12 -04003324 if (has_session && in->si_generation == 0)
J. Bruce Fields81b82962011-08-23 11:03:29 -04003325 return nfs_ok;
3326
3327 if (in->si_generation == ref->si_generation)
3328 return nfs_ok;
Andy Adamson66689582009-04-03 08:28:45 +03003329
J. Bruce Fields0836f582008-01-26 19:08:12 -05003330 /* If the client sends us a stateid from the future, it's buggy: */
J. Bruce Fields81b82962011-08-23 11:03:29 -04003331 if (stateid_generation_after(in, ref))
J. Bruce Fields0836f582008-01-26 19:08:12 -05003332 return nfserr_bad_stateid;
3333 /*
J. Bruce Fields81b82962011-08-23 11:03:29 -04003334 * However, we could see a stateid from the past, even from a
3335 * non-buggy client. For example, if the client sends a lock
3336 * while some IO is outstanding, the lock may bump si_generation
3337 * while the IO is still in flight. The client could avoid that
3338 * situation by waiting for responses on all the IO requests,
3339 * but better performance may result in retrying IO that
3340 * receives an old_stateid error if requests are rarely
3341 * reordered in flight:
J. Bruce Fields0836f582008-01-26 19:08:12 -05003342 */
J. Bruce Fields81b82962011-08-23 11:03:29 -04003343 return nfserr_old_stateid;
J. Bruce Fields0836f582008-01-26 19:08:12 -05003344}
3345
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04003346__be32 nfs4_validate_stateid(struct nfs4_client *cl, stateid_t *stateid)
Bryan Schumaker17456802011-07-13 10:50:48 -04003347{
J. Bruce Fields97b7e3b2011-09-09 11:26:58 -04003348 struct nfs4_stid *s;
3349 struct nfs4_ol_stateid *ols;
3350 __be32 status;
Bryan Schumaker17456802011-07-13 10:50:48 -04003351
3352 if (STALE_STATEID(stateid))
J. Bruce Fields97b7e3b2011-09-09 11:26:58 -04003353 return nfserr_stale_stateid;
Bryan Schumaker17456802011-07-13 10:50:48 -04003354
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04003355 s = find_stateid(cl, stateid);
J. Bruce Fields97b7e3b2011-09-09 11:26:58 -04003356 if (!s)
3357 return nfserr_stale_stateid;
J. Bruce Fields36279ac2011-09-26 12:53:00 -04003358 status = check_stateid_generation(stateid, &s->sc_stateid, 1);
Bryan Schumaker17456802011-07-13 10:50:48 -04003359 if (status)
J. Bruce Fields97b7e3b2011-09-09 11:26:58 -04003360 return status;
3361 if (!(s->sc_type & (NFS4_OPEN_STID | NFS4_LOCK_STID)))
3362 return nfs_ok;
3363 ols = openlockstateid(s);
3364 if (ols->st_stateowner->so_is_open_owner
J. Bruce Fieldsdad1c062011-09-12 12:24:13 -04003365 && !(openowner(ols->st_stateowner)->oo_flags & NFS4_OO_CONFIRMED))
J. Bruce Fields97b7e3b2011-09-09 11:26:58 -04003366 return nfserr_bad_stateid;
3367 return nfs_ok;
Bryan Schumaker17456802011-07-13 10:50:48 -04003368}
3369
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04003370static __be32 nfsd4_lookup_stateid(stateid_t *stateid, unsigned char typemask, struct nfs4_stid **s)
3371{
3372 struct nfs4_client *cl;
3373
3374 if (ZERO_STATEID(stateid) || ONE_STATEID(stateid))
3375 return nfserr_bad_stateid;
3376 if (STALE_STATEID(stateid))
3377 return nfserr_stale_stateid;
3378 cl = find_confirmed_client(&stateid->si_opaque.so_clid);
3379 if (!cl)
3380 return nfserr_expired;
3381 *s = find_stateid_by_type(cl, stateid, typemask);
3382 if (!*s)
3383 return nfserr_bad_stateid;
3384 return nfs_ok;
3385
3386}
3387
Linus Torvalds1da177e2005-04-16 15:20:36 -07003388/*
3389* Checks for stateid operations
3390*/
Al Virob37ad282006-10-19 23:28:59 -07003391__be32
Benny Halevydd453df2009-04-03 08:28:41 +03003392nfs4_preprocess_stateid_op(struct nfsd4_compound_state *cstate,
3393 stateid_t *stateid, int flags, struct file **filpp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003394{
J. Bruce Fields69064a22011-09-09 11:54:57 -04003395 struct nfs4_stid *s;
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04003396 struct nfs4_ol_stateid *stp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003397 struct nfs4_delegation *dp = NULL;
Benny Halevydd453df2009-04-03 08:28:41 +03003398 struct svc_fh *current_fh = &cstate->current_fh;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003399 struct inode *ino = current_fh->fh_dentry->d_inode;
Al Virob37ad282006-10-19 23:28:59 -07003400 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003401
Linus Torvalds1da177e2005-04-16 15:20:36 -07003402 if (filpp)
3403 *filpp = NULL;
3404
J. Bruce Fields18f82732009-02-21 15:23:01 -08003405 if (grace_disallows_io(ino))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003406 return nfserr_grace;
3407
3408 if (ZERO_STATEID(stateid) || ONE_STATEID(stateid))
3409 return check_special_stateids(current_fh, stateid, flags);
3410
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04003411 status = nfsd4_lookup_stateid(stateid, NFS4_DELEG_STID|NFS4_OPEN_STID|NFS4_LOCK_STID, &s);
3412 if (status)
3413 return status;
J. Bruce Fields69064a22011-09-09 11:54:57 -04003414 status = check_stateid_generation(stateid, &s->sc_stateid, nfsd4_has_session(cstate));
3415 if (status)
3416 goto out;
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -04003417 switch (s->sc_type) {
3418 case NFS4_DELEG_STID:
J. Bruce Fields69064a22011-09-09 11:54:57 -04003419 dp = delegstateid(s);
J. Bruce Fieldsdc9bf702009-02-21 11:14:43 -08003420 status = nfs4_check_delegmode(dp, flags);
3421 if (status)
3422 goto out;
Dan Carpenter43b01782010-10-27 23:19:04 +02003423 if (filpp) {
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05003424 *filpp = dp->dl_file->fi_deleg_file;
Dan Carpenter43b01782010-10-27 23:19:04 +02003425 BUG_ON(!*filpp);
3426 }
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -04003427 break;
3428 case NFS4_OPEN_STID:
3429 case NFS4_LOCK_STID:
J. Bruce Fields69064a22011-09-09 11:54:57 -04003430 stp = openlockstateid(s);
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -04003431 status = nfs4_check_fh(current_fh, stp);
3432 if (status)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003433 goto out;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003434 if (stp->st_stateowner->so_is_open_owner
J. Bruce Fieldsdad1c062011-09-12 12:24:13 -04003435 && !(openowner(stp->st_stateowner)->oo_flags & NFS4_OO_CONFIRMED))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003436 goto out;
J. Bruce Fieldsa4455be2009-02-21 10:40:22 -08003437 status = nfs4_check_openmode(stp, flags);
3438 if (status)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003439 goto out;
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04003440 if (filpp) {
3441 if (flags & RD_STATE)
3442 *filpp = find_readable_file(stp->st_file);
3443 else
3444 *filpp = find_writeable_file(stp->st_file);
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04003445 }
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -04003446 break;
3447 default:
3448 return nfserr_bad_stateid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003449 }
3450 status = nfs_ok;
3451out:
3452 return status;
3453}
3454
Bryan Schumakere1ca12d2011-07-13 11:04:21 -04003455static __be32
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04003456nfsd4_free_lock_stateid(struct nfs4_ol_stateid *stp)
Bryan Schumakere1ca12d2011-07-13 11:04:21 -04003457{
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003458 if (check_for_locks(stp->st_file, lockowner(stp->st_stateowner)))
Bryan Schumakere1ca12d2011-07-13 11:04:21 -04003459 return nfserr_locks_held;
3460 release_lock_stateid(stp);
3461 return nfs_ok;
3462}
3463
3464/*
Bryan Schumaker17456802011-07-13 10:50:48 -04003465 * Test if the stateid is valid
3466 */
3467__be32
3468nfsd4_test_stateid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
3469 struct nfsd4_test_stateid *test_stateid)
3470{
Bryan Schumaker03cfb422012-01-27 10:22:49 -05003471 struct nfsd4_test_stateid_id *stateid;
3472 struct nfs4_client *cl = cstate->session->se_client;
3473
3474 nfs4_lock_state();
3475 list_for_each_entry(stateid, &test_stateid->ts_stateid_list, ts_id_list)
3476 stateid->ts_id_status = nfs4_validate_stateid(cl, &stateid->ts_id_stateid);
3477 nfs4_unlock_state();
3478
Bryan Schumaker17456802011-07-13 10:50:48 -04003479 return nfs_ok;
3480}
3481
Bryan Schumakere1ca12d2011-07-13 11:04:21 -04003482__be32
3483nfsd4_free_stateid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
3484 struct nfsd4_free_stateid *free_stateid)
3485{
3486 stateid_t *stateid = &free_stateid->fr_stateid;
J. Bruce Fields2da1cec2011-09-16 18:56:20 -04003487 struct nfs4_stid *s;
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04003488 struct nfs4_client *cl = cstate->session->se_client;
J. Bruce Fields2da1cec2011-09-16 18:56:20 -04003489 __be32 ret = nfserr_bad_stateid;
Bryan Schumakere1ca12d2011-07-13 11:04:21 -04003490
3491 nfs4_lock_state();
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04003492 s = find_stateid(cl, stateid);
J. Bruce Fields2da1cec2011-09-16 18:56:20 -04003493 if (!s)
Bryan Schumakere1ca12d2011-07-13 11:04:21 -04003494 goto out;
J. Bruce Fields2da1cec2011-09-16 18:56:20 -04003495 switch (s->sc_type) {
3496 case NFS4_DELEG_STID:
Bryan Schumakere1ca12d2011-07-13 11:04:21 -04003497 ret = nfserr_locks_held;
3498 goto out;
J. Bruce Fields2da1cec2011-09-16 18:56:20 -04003499 case NFS4_OPEN_STID:
3500 case NFS4_LOCK_STID:
3501 ret = check_stateid_generation(stateid, &s->sc_stateid, 1);
3502 if (ret)
3503 goto out;
3504 if (s->sc_type == NFS4_LOCK_STID)
3505 ret = nfsd4_free_lock_stateid(openlockstateid(s));
3506 else
3507 ret = nfserr_locks_held;
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -04003508 break;
3509 default:
3510 ret = nfserr_bad_stateid;
Bryan Schumakere1ca12d2011-07-13 11:04:21 -04003511 }
Bryan Schumakere1ca12d2011-07-13 11:04:21 -04003512out:
3513 nfs4_unlock_state();
3514 return ret;
3515}
3516
NeilBrown4c4cd222005-07-07 17:59:27 -07003517static inline int
3518setlkflg (int type)
3519{
3520 return (type == NFS4_READW_LT || type == NFS4_READ_LT) ?
3521 RD_STATE : WR_STATE;
3522}
Linus Torvalds1da177e2005-04-16 15:20:36 -07003523
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04003524static __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 -04003525{
3526 struct svc_fh *current_fh = &cstate->current_fh;
3527 struct nfs4_stateowner *sop = stp->st_stateowner;
3528 __be32 status;
3529
J. Bruce Fieldsc0a5d932011-09-06 15:19:46 -04003530 status = nfsd4_check_seqid(cstate, sop, seqid);
3531 if (status)
3532 return status;
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -04003533 if (stp->st_stid.sc_type == NFS4_CLOSED_STID)
3534 /*
3535 * "Closed" stateid's exist *only* to return
3536 * nfserr_replay_me from the previous step.
3537 */
3538 return nfserr_bad_stateid;
3539 status = check_stateid_generation(stateid, &stp->st_stid.sc_stateid, nfsd4_has_session(cstate));
3540 if (status)
3541 return status;
3542 return nfs4_check_fh(current_fh, stp);
J. Bruce Fieldsc0a5d932011-09-06 15:19:46 -04003543}
3544
Linus Torvalds1da177e2005-04-16 15:20:36 -07003545/*
3546 * Checks for sequence id mutating operations.
3547 */
Al Virob37ad282006-10-19 23:28:59 -07003548static __be32
Benny Halevydd453df2009-04-03 08:28:41 +03003549nfs4_preprocess_seqid_op(struct nfsd4_compound_state *cstate, u32 seqid,
J. Bruce Fields2288d0e2011-09-06 15:50:21 -04003550 stateid_t *stateid, char typemask,
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04003551 struct nfs4_ol_stateid **stpp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003552{
J. Bruce Fields0836f582008-01-26 19:08:12 -05003553 __be32 status;
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04003554 struct nfs4_stid *s;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003555
Benny Halevy8c10cbd2009-10-19 12:04:53 +02003556 dprintk("NFSD: %s: seqid=%d stateid = " STATEID_FMT "\n", __func__,
3557 seqid, STATEID_VAL(stateid));
NeilBrown3a4f98b2005-07-07 17:59:26 -07003558
Linus Torvalds1da177e2005-04-16 15:20:36 -07003559 *stpp = NULL;
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04003560 status = nfsd4_lookup_stateid(stateid, typemask, &s);
J. Bruce Fieldsc0a5d932011-09-06 15:19:46 -04003561 if (status)
3562 return status;
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04003563 *stpp = openlockstateid(s);
J. Bruce Fieldsc0a5d932011-09-06 15:19:46 -04003564 cstate->replay_owner = (*stpp)->st_stateowner;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003565
J. Bruce Fieldsc0a5d932011-09-06 15:19:46 -04003566 return nfs4_seqid_op_checks(cstate, stateid, seqid, *stpp);
3567}
J. Bruce Fields39325bd2007-11-26 17:06:39 -05003568
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04003569static __be32 nfs4_preprocess_confirmed_seqid_op(struct nfsd4_compound_state *cstate, u32 seqid, stateid_t *stateid, struct nfs4_ol_stateid **stpp)
J. Bruce Fieldsc0a5d932011-09-06 15:19:46 -04003570{
3571 __be32 status;
3572 struct nfs4_openowner *oo;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003573
J. Bruce Fieldsc0a5d932011-09-06 15:19:46 -04003574 status = nfs4_preprocess_seqid_op(cstate, seqid, stateid,
J. Bruce Fields2288d0e2011-09-06 15:50:21 -04003575 NFS4_OPEN_STID, stpp);
J. Bruce Fields7a8711c2011-09-02 09:03:37 -04003576 if (status)
3577 return status;
J. Bruce Fieldsc0a5d932011-09-06 15:19:46 -04003578 oo = openowner((*stpp)->st_stateowner);
J. Bruce Fieldsdad1c062011-09-12 12:24:13 -04003579 if (!(oo->oo_flags & NFS4_OO_CONFIRMED))
NeilBrown3a4f98b2005-07-07 17:59:26 -07003580 return nfserr_bad_stateid;
NeilBrown3a4f98b2005-07-07 17:59:26 -07003581 return nfs_ok;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003582}
3583
Al Virob37ad282006-10-19 23:28:59 -07003584__be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003585nfsd4_open_confirm(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
J.Bruce Fieldsa4f1706a92006-12-13 00:35:28 -08003586 struct nfsd4_open_confirm *oc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003587{
Al Virob37ad282006-10-19 23:28:59 -07003588 __be32 status;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003589 struct nfs4_openowner *oo;
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04003590 struct nfs4_ol_stateid *stp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003591
3592 dprintk("NFSD: nfsd4_open_confirm on file %.*s\n",
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003593 (int)cstate->current_fh.fh_dentry->d_name.len,
3594 cstate->current_fh.fh_dentry->d_name.name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003595
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003596 status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0);
J. Bruce Fieldsa8cddc52006-06-30 01:56:13 -07003597 if (status)
3598 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003599
3600 nfs4_lock_state();
3601
J. Bruce Fields9072d5c2011-08-24 12:45:03 -04003602 status = nfs4_preprocess_seqid_op(cstate,
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003603 oc->oc_seqid, &oc->oc_req_stateid,
J. Bruce Fields2288d0e2011-09-06 15:50:21 -04003604 NFS4_OPEN_STID, &stp);
J. Bruce Fields9072d5c2011-08-24 12:45:03 -04003605 if (status)
J. Bruce Fields68b66e82011-09-02 12:19:43 -04003606 goto out;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003607 oo = openowner(stp->st_stateowner);
J. Bruce Fields68b66e82011-09-02 12:19:43 -04003608 status = nfserr_bad_stateid;
J. Bruce Fieldsdad1c062011-09-12 12:24:13 -04003609 if (oo->oo_flags & NFS4_OO_CONFIRMED)
J. Bruce Fields68b66e82011-09-02 12:19:43 -04003610 goto out;
J. Bruce Fieldsdad1c062011-09-12 12:24:13 -04003611 oo->oo_flags |= NFS4_OO_CONFIRMED;
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04003612 update_stateid(&stp->st_stid.sc_stateid);
3613 memcpy(&oc->oc_resp_stateid, &stp->st_stid.sc_stateid, sizeof(stateid_t));
Benny Halevy8c10cbd2009-10-19 12:04:53 +02003614 dprintk("NFSD: %s: success, seqid=%d stateid=" STATEID_FMT "\n",
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04003615 __func__, oc->oc_seqid, STATEID_VAL(&stp->st_stid.sc_stateid));
NeilBrownc7b9a452005-06-23 22:04:30 -07003616
Jeff Layton2a4317c2012-03-21 16:42:43 -04003617 nfsd4_client_record_create(oo->oo_owner.so_client);
J. Bruce Fields68b66e82011-09-02 12:19:43 -04003618 status = nfs_ok;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003619out:
J. Bruce Fields5ec094c2011-08-30 17:02:48 -04003620 if (!cstate->replay_owner)
3621 nfs4_unlock_state();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003622 return status;
3623}
3624
J. Bruce Fields6409a5a2011-09-28 11:37:56 -04003625static inline void nfs4_stateid_downgrade_bit(struct nfs4_ol_stateid *stp, u32 access)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003626{
Jeff Layton82c5ff12012-05-11 09:45:13 -04003627 if (!test_access(access, stp))
J. Bruce Fields6409a5a2011-09-28 11:37:56 -04003628 return;
3629 nfs4_file_put_access(stp->st_file, nfs4_access_to_omode(access));
Jeff Layton82c5ff12012-05-11 09:45:13 -04003630 clear_access(access, stp);
J. Bruce Fields6409a5a2011-09-28 11:37:56 -04003631}
J. Bruce Fieldsf197c272011-06-29 08:23:50 -04003632
J. Bruce Fields6409a5a2011-09-28 11:37:56 -04003633static inline void nfs4_stateid_downgrade(struct nfs4_ol_stateid *stp, u32 to_access)
3634{
3635 switch (to_access) {
3636 case NFS4_SHARE_ACCESS_READ:
3637 nfs4_stateid_downgrade_bit(stp, NFS4_SHARE_ACCESS_WRITE);
3638 nfs4_stateid_downgrade_bit(stp, NFS4_SHARE_ACCESS_BOTH);
3639 break;
3640 case NFS4_SHARE_ACCESS_WRITE:
3641 nfs4_stateid_downgrade_bit(stp, NFS4_SHARE_ACCESS_READ);
3642 nfs4_stateid_downgrade_bit(stp, NFS4_SHARE_ACCESS_BOTH);
3643 break;
3644 case NFS4_SHARE_ACCESS_BOTH:
3645 break;
3646 default:
3647 BUG();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003648 }
3649}
3650
3651static void
Jeff Laytonce0fc432012-05-11 09:45:14 -04003652reset_union_bmap_deny(unsigned long deny, struct nfs4_ol_stateid *stp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003653{
3654 int i;
3655 for (i = 0; i < 4; i++) {
3656 if ((i & deny) != i)
Jeff Laytonce0fc432012-05-11 09:45:14 -04003657 clear_deny(i, stp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003658 }
3659}
3660
Al Virob37ad282006-10-19 23:28:59 -07003661__be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003662nfsd4_open_downgrade(struct svc_rqst *rqstp,
3663 struct nfsd4_compound_state *cstate,
J.Bruce Fieldsa4f1706a92006-12-13 00:35:28 -08003664 struct nfsd4_open_downgrade *od)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003665{
Al Virob37ad282006-10-19 23:28:59 -07003666 __be32 status;
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04003667 struct nfs4_ol_stateid *stp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003668
3669 dprintk("NFSD: nfsd4_open_downgrade on file %.*s\n",
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003670 (int)cstate->current_fh.fh_dentry->d_name.len,
3671 cstate->current_fh.fh_dentry->d_name.name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003672
J. Bruce Fieldsc30e92d2011-10-10 17:34:31 -04003673 /* We don't yet support WANT bits: */
Benny Halevy2c8bd7e2012-02-16 20:57:09 +02003674 if (od->od_deleg_want)
3675 dprintk("NFSD: %s: od_deleg_want=0x%x ignored\n", __func__,
3676 od->od_deleg_want);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003677
3678 nfs4_lock_state();
J. Bruce Fieldsc0a5d932011-09-06 15:19:46 -04003679 status = nfs4_preprocess_confirmed_seqid_op(cstate, od->od_seqid,
3680 &od->od_stateid, &stp);
J. Bruce Fields9072d5c2011-08-24 12:45:03 -04003681 if (status)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003682 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003683 status = nfserr_inval;
Jeff Layton82c5ff12012-05-11 09:45:13 -04003684 if (!test_access(od->od_share_access, stp)) {
3685 dprintk("NFSD: access not a subset current bitmap: 0x%lx, input access=%08x\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07003686 stp->st_access_bmap, od->od_share_access);
3687 goto out;
3688 }
Jeff Laytonce0fc432012-05-11 09:45:14 -04003689 if (!test_deny(od->od_share_deny, stp)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003690 dprintk("NFSD:deny not a subset current bitmap: 0x%lx, input deny=%08x\n",
3691 stp->st_deny_bmap, od->od_share_deny);
3692 goto out;
3693 }
J. Bruce Fields6409a5a2011-09-28 11:37:56 -04003694 nfs4_stateid_downgrade(stp, od->od_share_access);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003695
Jeff Laytonce0fc432012-05-11 09:45:14 -04003696 reset_union_bmap_deny(od->od_share_deny, stp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003697
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04003698 update_stateid(&stp->st_stid.sc_stateid);
3699 memcpy(&od->od_stateid, &stp->st_stid.sc_stateid, sizeof(stateid_t));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003700 status = nfs_ok;
3701out:
J. Bruce Fields5ec094c2011-08-30 17:02:48 -04003702 if (!cstate->replay_owner)
3703 nfs4_unlock_state();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003704 return status;
3705}
3706
J. Bruce Fields38c387b2011-09-16 17:42:48 -04003707void nfsd4_purge_closed_stateid(struct nfs4_stateowner *so)
3708{
3709 struct nfs4_openowner *oo;
3710 struct nfs4_ol_stateid *s;
3711
3712 if (!so->so_is_open_owner)
3713 return;
3714 oo = openowner(so);
3715 s = oo->oo_last_closed_stid;
3716 if (!s)
3717 return;
3718 if (!(oo->oo_flags & NFS4_OO_PURGE_CLOSE)) {
3719 /* Release the last_closed_stid on the next seqid bump: */
3720 oo->oo_flags |= NFS4_OO_PURGE_CLOSE;
3721 return;
3722 }
3723 oo->oo_flags &= ~NFS4_OO_PURGE_CLOSE;
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -04003724 release_last_closed_stateid(oo);
3725}
3726
3727static void nfsd4_close_open_stateid(struct nfs4_ol_stateid *s)
3728{
3729 unhash_open_stateid(s);
3730 s->st_stid.sc_type = NFS4_CLOSED_STID;
J. Bruce Fields38c387b2011-09-16 17:42:48 -04003731}
3732
Linus Torvalds1da177e2005-04-16 15:20:36 -07003733/*
3734 * nfs4_unlock_state() called after encode
3735 */
Al Virob37ad282006-10-19 23:28:59 -07003736__be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003737nfsd4_close(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
J.Bruce Fieldsa4f1706a92006-12-13 00:35:28 -08003738 struct nfsd4_close *close)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003739{
Al Virob37ad282006-10-19 23:28:59 -07003740 __be32 status;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003741 struct nfs4_openowner *oo;
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04003742 struct nfs4_ol_stateid *stp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003743
3744 dprintk("NFSD: nfsd4_close on file %.*s\n",
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003745 (int)cstate->current_fh.fh_dentry->d_name.len,
3746 cstate->current_fh.fh_dentry->d_name.name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003747
3748 nfs4_lock_state();
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -04003749 status = nfs4_preprocess_seqid_op(cstate, close->cl_seqid,
3750 &close->cl_stateid,
3751 NFS4_OPEN_STID|NFS4_CLOSED_STID,
3752 &stp);
J. Bruce Fields9072d5c2011-08-24 12:45:03 -04003753 if (status)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003754 goto out;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003755 oo = openowner(stp->st_stateowner);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003756 status = nfs_ok;
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04003757 update_stateid(&stp->st_stid.sc_stateid);
3758 memcpy(&close->cl_stateid, &stp->st_stid.sc_stateid, sizeof(stateid_t));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003759
J. Bruce Fieldsf7a4d872011-09-16 20:12:38 -04003760 nfsd4_close_open_stateid(stp);
J. Bruce Fields38c387b2011-09-16 17:42:48 -04003761 oo->oo_last_closed_stid = stp;
J. Bruce Fields04ef5952006-01-18 17:43:21 -08003762
3763 /* place unused nfs4_stateowners on so_close_lru list to be
3764 * released by the laundromat service after the lease period
3765 * to enable us to handle CLOSE replay
3766 */
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003767 if (list_empty(&oo->oo_owner.so_stateids))
3768 move_to_close_lru(oo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003769out:
J. Bruce Fields5ec094c2011-08-30 17:02:48 -04003770 if (!cstate->replay_owner)
3771 nfs4_unlock_state();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003772 return status;
3773}
3774
Al Virob37ad282006-10-19 23:28:59 -07003775__be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003776nfsd4_delegreturn(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
3777 struct nfsd4_delegreturn *dr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003778{
J. Bruce Fields203a8c82009-02-21 13:29:14 -08003779 struct nfs4_delegation *dp;
3780 stateid_t *stateid = &dr->dr_stateid;
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04003781 struct nfs4_stid *s;
J. Bruce Fields203a8c82009-02-21 13:29:14 -08003782 struct inode *inode;
Al Virob37ad282006-10-19 23:28:59 -07003783 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003784
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003785 if ((status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0)))
J. Bruce Fields203a8c82009-02-21 13:29:14 -08003786 return status;
3787 inode = cstate->current_fh.fh_dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003788
3789 nfs4_lock_state();
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04003790 status = nfsd4_lookup_stateid(stateid, NFS4_DELEG_STID, &s);
3791 if (status)
J. Bruce Fields203a8c82009-02-21 13:29:14 -08003792 goto out;
J. Bruce Fields38c2f4b2011-09-23 17:01:19 -04003793 dp = delegstateid(s);
J. Bruce Fieldsd5477a82011-09-08 12:07:44 -04003794 status = check_stateid_generation(stateid, &dp->dl_stid.sc_stateid, nfsd4_has_session(cstate));
J. Bruce Fields203a8c82009-02-21 13:29:14 -08003795 if (status)
3796 goto out;
J. Bruce Fields203a8c82009-02-21 13:29:14 -08003797
3798 unhash_delegation(dp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003799out:
J. Bruce Fields203a8c82009-02-21 13:29:14 -08003800 nfs4_unlock_state();
3801
Linus Torvalds1da177e2005-04-16 15:20:36 -07003802 return status;
3803}
3804
3805
Linus Torvalds1da177e2005-04-16 15:20:36 -07003806#define LOFF_OVERFLOW(start, len) ((u64)(len) > ~(u64)(start))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003807
J. Bruce Fields009673b2011-11-07 17:40:10 -05003808#define LOCKOWNER_INO_HASH_BITS 8
3809#define LOCKOWNER_INO_HASH_SIZE (1 << LOCKOWNER_INO_HASH_BITS)
3810#define LOCKOWNER_INO_HASH_MASK (LOCKOWNER_INO_HASH_SIZE - 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003811
Benny Halevy87df4de2008-12-15 19:42:03 +02003812static inline u64
3813end_offset(u64 start, u64 len)
3814{
3815 u64 end;
3816
3817 end = start + len;
3818 return end >= start ? end: NFS4_MAX_UINT64;
3819}
3820
3821/* last octet in a range */
3822static inline u64
3823last_byte_offset(u64 start, u64 len)
3824{
3825 u64 end;
3826
3827 BUG_ON(!len);
3828 end = start + len;
3829 return end > start ? end - 1: NFS4_MAX_UINT64;
3830}
3831
J. Bruce Fields009673b2011-11-07 17:40:10 -05003832static unsigned int lockowner_ino_hashval(struct inode *inode, u32 cl_id, struct xdr_netobj *ownername)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003833{
3834 return (file_hashval(inode) + cl_id
3835 + opaque_hashval(ownername->data, ownername->len))
J. Bruce Fields009673b2011-11-07 17:40:10 -05003836 & LOCKOWNER_INO_HASH_MASK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003837}
3838
J. Bruce Fields009673b2011-11-07 17:40:10 -05003839static struct list_head lockowner_ino_hashtbl[LOCKOWNER_INO_HASH_SIZE];
Linus Torvalds1da177e2005-04-16 15:20:36 -07003840
Linus Torvalds1da177e2005-04-16 15:20:36 -07003841/*
3842 * TODO: Linux file offsets are _signed_ 64-bit quantities, which means that
3843 * we can't properly handle lock requests that go beyond the (2^63 - 1)-th
3844 * byte, because of sign extension problems. Since NFSv4 calls for 64-bit
3845 * locking, this prevents us from being completely protocol-compliant. The
3846 * real solution to this problem is to start using unsigned file offsets in
3847 * the VFS, but this is a very deep change!
3848 */
3849static inline void
3850nfs4_transform_lock_offset(struct file_lock *lock)
3851{
3852 if (lock->fl_start < 0)
3853 lock->fl_start = OFFSET_MAX;
3854 if (lock->fl_end < 0)
3855 lock->fl_end = OFFSET_MAX;
3856}
3857
NeilBrownd5b90262006-04-10 22:55:22 -07003858/* Hack!: For now, we're defining this just so we can use a pointer to it
3859 * as a unique cookie to identify our (NFSv4's) posix locks. */
Alexey Dobriyan7b021962009-09-21 17:01:12 -07003860static const struct lock_manager_operations nfsd_posix_mng_ops = {
NeilBrownd5b90262006-04-10 22:55:22 -07003861};
Linus Torvalds1da177e2005-04-16 15:20:36 -07003862
3863static inline void
3864nfs4_set_lock_denied(struct file_lock *fl, struct nfsd4_lock_denied *deny)
3865{
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003866 struct nfs4_lockowner *lo;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003867
NeilBrownd5b90262006-04-10 22:55:22 -07003868 if (fl->fl_lmops == &nfsd_posix_mng_ops) {
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003869 lo = (struct nfs4_lockowner *) fl->fl_owner;
3870 deny->ld_owner.data = kmemdup(lo->lo_owner.so_owner.data,
3871 lo->lo_owner.so_owner.len, GFP_KERNEL);
J. Bruce Fields7c13f342011-08-30 22:15:47 -04003872 if (!deny->ld_owner.data)
3873 /* We just don't care that much */
3874 goto nevermind;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003875 deny->ld_owner.len = lo->lo_owner.so_owner.len;
3876 deny->ld_clientid = lo->lo_owner.so_client->cl_clientid;
NeilBrownd5b90262006-04-10 22:55:22 -07003877 } else {
J. Bruce Fields7c13f342011-08-30 22:15:47 -04003878nevermind:
3879 deny->ld_owner.len = 0;
3880 deny->ld_owner.data = NULL;
NeilBrownd5b90262006-04-10 22:55:22 -07003881 deny->ld_clientid.cl_boot = 0;
3882 deny->ld_clientid.cl_id = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003883 }
3884 deny->ld_start = fl->fl_start;
Benny Halevy87df4de2008-12-15 19:42:03 +02003885 deny->ld_length = NFS4_MAX_UINT64;
3886 if (fl->fl_end != NFS4_MAX_UINT64)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003887 deny->ld_length = fl->fl_end - fl->fl_start + 1;
3888 deny->ld_type = NFS4_READ_LT;
3889 if (fl->fl_type != F_RDLCK)
3890 deny->ld_type = NFS4_WRITE_LT;
3891}
3892
J. Bruce Fieldsb93d87c2011-11-07 16:37:57 -05003893static bool same_lockowner_ino(struct nfs4_lockowner *lo, struct inode *inode, clientid_t *clid, struct xdr_netobj *owner)
3894{
3895 struct nfs4_ol_stateid *lst;
3896
3897 if (!same_owner_str(&lo->lo_owner, owner, clid))
3898 return false;
3899 lst = list_first_entry(&lo->lo_owner.so_stateids,
3900 struct nfs4_ol_stateid, st_perstateowner);
3901 return lst->st_file->fi_inode == inode;
3902}
3903
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003904static struct nfs4_lockowner *
3905find_lockowner_str(struct inode *inode, clientid_t *clid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003906 struct xdr_netobj *owner)
3907{
J. Bruce Fields009673b2011-11-07 17:40:10 -05003908 unsigned int hashval = lockowner_ino_hashval(inode, clid->cl_id, owner);
J. Bruce Fieldsb93d87c2011-11-07 16:37:57 -05003909 struct nfs4_lockowner *lo;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003910
J. Bruce Fields009673b2011-11-07 17:40:10 -05003911 list_for_each_entry(lo, &lockowner_ino_hashtbl[hashval], lo_owner_ino_hash) {
J. Bruce Fieldsb93d87c2011-11-07 16:37:57 -05003912 if (same_lockowner_ino(lo, inode, clid, owner))
3913 return lo;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003914 }
3915 return NULL;
3916}
3917
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04003918static 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 -04003919{
J. Bruce Fields009673b2011-11-07 17:40:10 -05003920 struct inode *inode = open_stp->st_file->fi_inode;
3921 unsigned int inohash = lockowner_ino_hashval(inode,
3922 clp->cl_clientid.cl_id, &lo->lo_owner.so_owner);
3923
J. Bruce Fields16bfdaaf2011-11-07 17:23:30 -05003924 list_add(&lo->lo_owner.so_strhash, &ownerstr_hashtbl[strhashval]);
J. Bruce Fields009673b2011-11-07 17:40:10 -05003925 list_add(&lo->lo_owner_ino_hash, &lockowner_ino_hashtbl[inohash]);
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003926 list_add(&lo->lo_perstateid, &open_stp->st_lockowners);
J. Bruce Fieldsff194bd2011-08-12 09:42:57 -04003927}
3928
Linus Torvalds1da177e2005-04-16 15:20:36 -07003929/*
3930 * Alloc a lock owner structure.
3931 * Called in nfsd4_lock - therefore, OPEN and OPEN_CONFIRM (if needed) has
Lucas De Marchi25985ed2011-03-30 22:57:33 -03003932 * occurred.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003933 *
J. Bruce Fields16bfdaaf2011-11-07 17:23:30 -05003934 * strhashval = ownerstr_hashval
Linus Torvalds1da177e2005-04-16 15:20:36 -07003935 */
3936
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003937static struct nfs4_lockowner *
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04003938alloc_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 -04003939 struct nfs4_lockowner *lo;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003940
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003941 lo = alloc_stateowner(lockowner_slab, &lock->lk_new_owner, clp);
3942 if (!lo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003943 return NULL;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003944 INIT_LIST_HEAD(&lo->lo_owner.so_stateids);
3945 lo->lo_owner.so_is_open_owner = 0;
Neil Brownb59e3c02005-09-13 01:25:38 -07003946 /* It is the openowner seqid that will be incremented in encode in the
3947 * case of new lockowners; so increment the lock seqid manually: */
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003948 lo->lo_owner.so_seqid = lock->lk_new_lock_seqid + 1;
3949 hash_lockowner(lo, strhashval, clp, open_stp);
3950 return lo;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003951}
3952
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04003953static struct nfs4_ol_stateid *
3954alloc_init_lock_stateid(struct nfs4_lockowner *lo, struct nfs4_file *fp, struct nfs4_ol_stateid *open_stp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003955{
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04003956 struct nfs4_ol_stateid *stp;
J. Bruce Fieldsd3b313a2011-09-15 15:02:41 -04003957 struct nfs4_client *clp = lo->lo_owner.so_client;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003958
J. Bruce Fields996e0932011-10-17 11:14:48 -04003959 stp = nfs4_alloc_stateid(clp);
NeilBrown5ac049a2005-06-23 22:03:03 -07003960 if (stp == NULL)
J. Bruce Fields6136d2b2011-09-23 16:21:15 -04003961 return NULL;
J. Bruce Fields996e0932011-10-17 11:14:48 -04003962 init_stid(&stp->st_stid, clp, NFS4_LOCK_STID);
NeilBrown8beefa22005-06-23 22:03:08 -07003963 list_add(&stp->st_perfile, &fp->fi_stateids);
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04003964 list_add(&stp->st_perstateowner, &lo->lo_owner.so_stateids);
3965 stp->st_stateowner = &lo->lo_owner;
NeilBrown13cd2182005-06-23 22:03:10 -07003966 get_nfs4_file(fp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003967 stp->st_file = fp;
J. Bruce Fields0997b172011-03-02 18:01:35 -05003968 stp->st_access_bmap = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003969 stp->st_deny_bmap = open_stp->st_deny_bmap;
NeilBrown4c4cd222005-07-07 17:59:27 -07003970 stp->st_openstp = open_stp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003971 return stp;
3972}
3973
NeilBrownfd39ca92005-06-23 22:04:03 -07003974static int
Linus Torvalds1da177e2005-04-16 15:20:36 -07003975check_lock_length(u64 offset, u64 length)
3976{
Benny Halevy87df4de2008-12-15 19:42:03 +02003977 return ((length == 0) || ((length != NFS4_MAX_UINT64) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07003978 LOFF_OVERFLOW(offset, length)));
3979}
3980
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04003981static void get_lock_access(struct nfs4_ol_stateid *lock_stp, u32 access)
J. Bruce Fields0997b172011-03-02 18:01:35 -05003982{
3983 struct nfs4_file *fp = lock_stp->st_file;
3984 int oflag = nfs4_access_to_omode(access);
3985
Jeff Layton82c5ff12012-05-11 09:45:13 -04003986 if (test_access(access, lock_stp))
J. Bruce Fields0997b172011-03-02 18:01:35 -05003987 return;
3988 nfs4_file_get_access(fp, oflag);
Jeff Layton82c5ff12012-05-11 09:45:13 -04003989 set_access(access, lock_stp);
J. Bruce Fields0997b172011-03-02 18:01:35 -05003990}
3991
J. Bruce Fields2355c592012-04-25 16:56:22 -04003992static __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 -04003993{
3994 struct nfs4_file *fi = ost->st_file;
3995 struct nfs4_openowner *oo = openowner(ost->st_stateowner);
3996 struct nfs4_client *cl = oo->oo_owner.so_client;
3997 struct nfs4_lockowner *lo;
3998 unsigned int strhashval;
3999
4000 lo = find_lockowner_str(fi->fi_inode, &cl->cl_clientid, &lock->v.new.owner);
4001 if (lo) {
4002 if (!cstate->minorversion)
4003 return nfserr_bad_seqid;
4004 /* XXX: a lockowner always has exactly one stateid: */
4005 *lst = list_first_entry(&lo->lo_owner.so_stateids,
4006 struct nfs4_ol_stateid, st_perstateowner);
4007 return nfs_ok;
4008 }
J. Bruce Fields16bfdaaf2011-11-07 17:23:30 -05004009 strhashval = ownerstr_hashval(cl->cl_clientid.cl_id,
J. Bruce Fields64a284d2011-10-20 06:57:46 -04004010 &lock->v.new.owner);
4011 lo = alloc_init_lock_stateowner(strhashval, cl, ost, lock);
4012 if (lo == NULL)
4013 return nfserr_jukebox;
4014 *lst = alloc_init_lock_stateid(lo, fi, ost);
4015 if (*lst == NULL) {
4016 release_lockowner(lo);
4017 return nfserr_jukebox;
4018 }
4019 *new = true;
4020 return nfs_ok;
4021}
4022
Linus Torvalds1da177e2005-04-16 15:20:36 -07004023/*
4024 * LOCK operation
4025 */
Al Virob37ad282006-10-19 23:28:59 -07004026__be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -08004027nfsd4_lock(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
J.Bruce Fieldsa4f1706a92006-12-13 00:35:28 -08004028 struct nfsd4_lock *lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004029{
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004030 struct nfs4_openowner *open_sop = NULL;
4031 struct nfs4_lockowner *lock_sop = NULL;
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04004032 struct nfs4_ol_stateid *lock_stp;
J. Bruce Fields7d947842010-08-20 18:09:31 -04004033 struct file *filp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004034 struct file_lock file_lock;
Andy Adamson8dc7c312006-03-20 13:44:26 -05004035 struct file_lock conflock;
Al Virob37ad282006-10-19 23:28:59 -07004036 __be32 status = 0;
J. Bruce Fields64a284d2011-10-20 06:57:46 -04004037 bool new_state = false;
J. Bruce Fieldsb34f27a2011-08-22 13:13:31 -04004038 int lkflg;
Al Virob8dd7b92006-10-19 23:29:01 -07004039 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004040
4041 dprintk("NFSD: nfsd4_lock: start=%Ld length=%Ld\n",
4042 (long long) lock->lk_offset,
4043 (long long) lock->lk_length);
4044
Linus Torvalds1da177e2005-04-16 15:20:36 -07004045 if (check_lock_length(lock->lk_offset, lock->lk_length))
4046 return nfserr_inval;
4047
J.Bruce Fieldsca364312006-12-13 00:35:27 -08004048 if ((status = fh_verify(rqstp, &cstate->current_fh,
Miklos Szeredi8837abc2008-06-16 13:20:29 +02004049 S_IFREG, NFSD_MAY_LOCK))) {
Andy Adamsona6f6ef22006-01-18 17:43:17 -08004050 dprintk("NFSD: nfsd4_lock: permission denied!\n");
4051 return status;
4052 }
4053
Linus Torvalds1da177e2005-04-16 15:20:36 -07004054 nfs4_lock_state();
4055
4056 if (lock->lk_is_new) {
NeilBrown893f8772005-07-07 17:59:17 -07004057 /*
4058 * Client indicates that this is a new lockowner.
4059 * Use open owner and open stateid to create lock owner and
4060 * lock stateid.
4061 */
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04004062 struct nfs4_ol_stateid *open_stp = NULL;
J. Bruce Fields684e5632011-11-04 17:08:10 -04004063
4064 if (nfsd4_has_session(cstate))
4065 /* See rfc 5661 18.10.3: given clientid is ignored: */
4066 memcpy(&lock->v.new.clientid,
4067 &cstate->session->se_client->cl_clientid,
4068 sizeof(clientid_t));
4069
Linus Torvalds1da177e2005-04-16 15:20:36 -07004070 status = nfserr_stale_clientid;
J. Bruce Fields684e5632011-11-04 17:08:10 -04004071 if (STALE_CLIENTID(&lock->lk_new_clientid))
Linus Torvalds1da177e2005-04-16 15:20:36 -07004072 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004073
Linus Torvalds1da177e2005-04-16 15:20:36 -07004074 /* validate and update open stateid and open seqid */
J. Bruce Fieldsc0a5d932011-09-06 15:19:46 -04004075 status = nfs4_preprocess_confirmed_seqid_op(cstate,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004076 lock->lk_new_open_seqid,
4077 &lock->lk_new_open_stateid,
J. Bruce Fieldsc0a5d932011-09-06 15:19:46 -04004078 &open_stp);
NeilBrown37515172005-07-07 17:59:16 -07004079 if (status)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004080 goto out;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004081 open_sop = openowner(open_stp->st_stateowner);
J. Bruce Fieldsb34f27a2011-08-22 13:13:31 -04004082 status = nfserr_bad_stateid;
J. Bruce Fields684e5632011-11-04 17:08:10 -04004083 if (!same_clid(&open_sop->oo_owner.so_client->cl_clientid,
J. Bruce Fieldsb34f27a2011-08-22 13:13:31 -04004084 &lock->v.new.clientid))
4085 goto out;
J. Bruce Fields64a284d2011-10-20 06:57:46 -04004086 status = lookup_or_create_lock_state(cstate, open_stp, lock,
4087 &lock_stp, &new_state);
4088 if (status)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004089 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004090 } else {
4091 /* lock (lock owner + lock stateid) already exists */
Benny Halevydd453df2009-04-03 08:28:41 +03004092 status = nfs4_preprocess_seqid_op(cstate,
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004093 lock->lk_old_lock_seqid,
4094 &lock->lk_old_lock_stateid,
J. Bruce Fields2288d0e2011-09-06 15:50:21 -04004095 NFS4_LOCK_STID, &lock_stp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004096 if (status)
4097 goto out;
4098 }
J. Bruce Fields64a284d2011-10-20 06:57:46 -04004099 lock_sop = lockowner(lock_stp->st_stateowner);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004100
J. Bruce Fieldsb34f27a2011-08-22 13:13:31 -04004101 lkflg = setlkflg(lock->lk_type);
4102 status = nfs4_check_openmode(lock_stp, lkflg);
4103 if (status)
4104 goto out;
4105
NeilBrown0dd395d2005-07-07 17:59:15 -07004106 status = nfserr_grace;
J. Bruce Fieldsaf558e32007-09-06 12:34:25 -04004107 if (locks_in_grace() && !lock->lk_reclaim)
NeilBrown0dd395d2005-07-07 17:59:15 -07004108 goto out;
4109 status = nfserr_no_grace;
J. Bruce Fieldsaf558e32007-09-06 12:34:25 -04004110 if (!locks_in_grace() && lock->lk_reclaim)
NeilBrown0dd395d2005-07-07 17:59:15 -07004111 goto out;
4112
Linus Torvalds1da177e2005-04-16 15:20:36 -07004113 locks_init_lock(&file_lock);
4114 switch (lock->lk_type) {
4115 case NFS4_READ_LT:
4116 case NFS4_READW_LT:
J. Bruce Fields0997b172011-03-02 18:01:35 -05004117 filp = find_readable_file(lock_stp->st_file);
4118 if (filp)
4119 get_lock_access(lock_stp, NFS4_SHARE_ACCESS_READ);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004120 file_lock.fl_type = F_RDLCK;
J. Bruce Fields529d7b22011-03-02 23:48:33 -05004121 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004122 case NFS4_WRITE_LT:
4123 case NFS4_WRITEW_LT:
J. Bruce Fields0997b172011-03-02 18:01:35 -05004124 filp = find_writeable_file(lock_stp->st_file);
4125 if (filp)
4126 get_lock_access(lock_stp, NFS4_SHARE_ACCESS_WRITE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004127 file_lock.fl_type = F_WRLCK;
J. Bruce Fields529d7b22011-03-02 23:48:33 -05004128 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004129 default:
4130 status = nfserr_inval;
4131 goto out;
4132 }
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04004133 if (!filp) {
4134 status = nfserr_openmode;
4135 goto out;
4136 }
Neil Brownb59e3c02005-09-13 01:25:38 -07004137 file_lock.fl_owner = (fl_owner_t)lock_sop;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004138 file_lock.fl_pid = current->tgid;
4139 file_lock.fl_file = filp;
4140 file_lock.fl_flags = FL_POSIX;
NeilBrownd5b90262006-04-10 22:55:22 -07004141 file_lock.fl_lmops = &nfsd_posix_mng_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004142
4143 file_lock.fl_start = lock->lk_offset;
Benny Halevy87df4de2008-12-15 19:42:03 +02004144 file_lock.fl_end = last_byte_offset(lock->lk_offset, lock->lk_length);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004145 nfs4_transform_lock_offset(&file_lock);
4146
4147 /*
4148 * Try to lock the file in the VFS.
4149 * Note: locks.c uses the BKL to protect the inode's lock list.
4150 */
4151
J. Bruce Fields529d7b22011-03-02 23:48:33 -05004152 err = vfs_lock_file(filp, F_SETLK, &file_lock, &conflock);
Al Virob8dd7b92006-10-19 23:29:01 -07004153 switch (-err) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004154 case 0: /* success! */
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04004155 update_stateid(&lock_stp->st_stid.sc_stateid);
4156 memcpy(&lock->lk_resp_stateid, &lock_stp->st_stid.sc_stateid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004157 sizeof(stateid_t));
Al Virob8dd7b92006-10-19 23:29:01 -07004158 status = 0;
Andy Adamsoneb76b3f2006-03-26 01:37:26 -08004159 break;
4160 case (EAGAIN): /* conflock holds conflicting lock */
4161 status = nfserr_denied;
4162 dprintk("NFSD: nfsd4_lock: conflicting lock found!\n");
4163 nfs4_set_lock_denied(&conflock, &lock->lk_denied);
4164 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004165 case (EDEADLK):
4166 status = nfserr_deadlock;
Andy Adamsoneb76b3f2006-03-26 01:37:26 -08004167 break;
J. Bruce Fields3e772462011-08-10 19:07:33 -04004168 default:
Marc Eshelfd85b812006-11-28 16:26:41 -05004169 dprintk("NFSD: nfsd4_lock: vfs_lock_file() failed! status %d\n",err);
J. Bruce Fields3e772462011-08-10 19:07:33 -04004170 status = nfserrno(err);
Andy Adamsoneb76b3f2006-03-26 01:37:26 -08004171 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004172 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004173out:
J. Bruce Fields64a284d2011-10-20 06:57:46 -04004174 if (status && new_state)
J. Bruce Fieldsf044ff82009-01-11 15:24:04 -05004175 release_lockowner(lock_sop);
J. Bruce Fields5ec094c2011-08-30 17:02:48 -04004176 if (!cstate->replay_owner)
4177 nfs4_unlock_state();
Linus Torvalds1da177e2005-04-16 15:20:36 -07004178 return status;
4179}
4180
4181/*
J. Bruce Fields55ef1272008-12-20 11:58:38 -08004182 * The NFSv4 spec allows a client to do a LOCKT without holding an OPEN,
4183 * so we do a temporary open here just to get an open file to pass to
4184 * vfs_test_lock. (Arguably perhaps test_lock should be done with an
4185 * inode operation.)
4186 */
4187static int nfsd_test_lock(struct svc_rqst *rqstp, struct svc_fh *fhp, struct file_lock *lock)
4188{
4189 struct file *file;
4190 int err;
4191
4192 err = nfsd_open(rqstp, fhp, S_IFREG, NFSD_MAY_READ, &file);
4193 if (err)
4194 return err;
4195 err = vfs_test_lock(file, lock);
4196 nfsd_close(file);
4197 return err;
4198}
4199
4200/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07004201 * LOCKT operation
4202 */
Al Virob37ad282006-10-19 23:28:59 -07004203__be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -08004204nfsd4_lockt(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
4205 struct nfsd4_lockt *lockt)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004206{
4207 struct inode *inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004208 struct file_lock file_lock;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004209 struct nfs4_lockowner *lo;
Marc Eshelfd85b812006-11-28 16:26:41 -05004210 int error;
Al Virob37ad282006-10-19 23:28:59 -07004211 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004212
J. Bruce Fieldsaf558e32007-09-06 12:34:25 -04004213 if (locks_in_grace())
Linus Torvalds1da177e2005-04-16 15:20:36 -07004214 return nfserr_grace;
4215
4216 if (check_lock_length(lockt->lt_offset, lockt->lt_length))
4217 return nfserr_inval;
4218
Linus Torvalds1da177e2005-04-16 15:20:36 -07004219 nfs4_lock_state();
4220
4221 status = nfserr_stale_clientid;
Andy Adamson60adfc52009-04-03 08:28:50 +03004222 if (!nfsd4_has_session(cstate) && STALE_CLIENTID(&lockt->lt_clientid))
Linus Torvalds1da177e2005-04-16 15:20:36 -07004223 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004224
J. Bruce Fields75c096f2011-08-15 18:39:32 -04004225 if ((status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07004226 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004227
J.Bruce Fieldsca364312006-12-13 00:35:27 -08004228 inode = cstate->current_fh.fh_dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004229 locks_init_lock(&file_lock);
4230 switch (lockt->lt_type) {
4231 case NFS4_READ_LT:
4232 case NFS4_READW_LT:
4233 file_lock.fl_type = F_RDLCK;
4234 break;
4235 case NFS4_WRITE_LT:
4236 case NFS4_WRITEW_LT:
4237 file_lock.fl_type = F_WRLCK;
4238 break;
4239 default:
J. Bruce Fields2fdada02007-07-27 16:10:37 -04004240 dprintk("NFSD: nfs4_lockt: bad lock type!\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07004241 status = nfserr_inval;
4242 goto out;
4243 }
4244
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004245 lo = find_lockowner_str(inode, &lockt->lt_clientid, &lockt->lt_owner);
4246 if (lo)
4247 file_lock.fl_owner = (fl_owner_t)lo;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004248 file_lock.fl_pid = current->tgid;
4249 file_lock.fl_flags = FL_POSIX;
4250
4251 file_lock.fl_start = lockt->lt_offset;
Benny Halevy87df4de2008-12-15 19:42:03 +02004252 file_lock.fl_end = last_byte_offset(lockt->lt_offset, lockt->lt_length);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004253
4254 nfs4_transform_lock_offset(&file_lock);
4255
Linus Torvalds1da177e2005-04-16 15:20:36 -07004256 status = nfs_ok;
J. Bruce Fields55ef1272008-12-20 11:58:38 -08004257 error = nfsd_test_lock(rqstp, &cstate->current_fh, &file_lock);
Marc Eshelfd85b812006-11-28 16:26:41 -05004258 if (error) {
4259 status = nfserrno(error);
4260 goto out;
4261 }
Marc Eshel9d6a8c52007-02-21 00:55:18 -05004262 if (file_lock.fl_type != F_UNLCK) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004263 status = nfserr_denied;
Marc Eshel9d6a8c52007-02-21 00:55:18 -05004264 nfs4_set_lock_denied(&file_lock, &lockt->lt_denied);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004265 }
4266out:
4267 nfs4_unlock_state();
4268 return status;
4269}
4270
Al Virob37ad282006-10-19 23:28:59 -07004271__be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -08004272nfsd4_locku(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
J.Bruce Fieldsa4f1706a92006-12-13 00:35:28 -08004273 struct nfsd4_locku *locku)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004274{
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04004275 struct nfs4_ol_stateid *stp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004276 struct file *filp = NULL;
4277 struct file_lock file_lock;
Al Virob37ad282006-10-19 23:28:59 -07004278 __be32 status;
Al Virob8dd7b92006-10-19 23:29:01 -07004279 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004280
4281 dprintk("NFSD: nfsd4_locku: start=%Ld length=%Ld\n",
4282 (long long) locku->lu_offset,
4283 (long long) locku->lu_length);
4284
4285 if (check_lock_length(locku->lu_offset, locku->lu_length))
4286 return nfserr_inval;
4287
4288 nfs4_lock_state();
4289
J. Bruce Fields9072d5c2011-08-24 12:45:03 -04004290 status = nfs4_preprocess_seqid_op(cstate, locku->lu_seqid,
J. Bruce Fields2288d0e2011-09-06 15:50:21 -04004291 &locku->lu_stateid, NFS4_LOCK_STID, &stp);
J. Bruce Fields9072d5c2011-08-24 12:45:03 -04004292 if (status)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004293 goto out;
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04004294 filp = find_any_file(stp->st_file);
4295 if (!filp) {
4296 status = nfserr_lock_range;
4297 goto out;
4298 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004299 BUG_ON(!filp);
4300 locks_init_lock(&file_lock);
4301 file_lock.fl_type = F_UNLCK;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004302 file_lock.fl_owner = (fl_owner_t)lockowner(stp->st_stateowner);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004303 file_lock.fl_pid = current->tgid;
4304 file_lock.fl_file = filp;
4305 file_lock.fl_flags = FL_POSIX;
NeilBrownd5b90262006-04-10 22:55:22 -07004306 file_lock.fl_lmops = &nfsd_posix_mng_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004307 file_lock.fl_start = locku->lu_offset;
4308
Benny Halevy87df4de2008-12-15 19:42:03 +02004309 file_lock.fl_end = last_byte_offset(locku->lu_offset, locku->lu_length);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004310 nfs4_transform_lock_offset(&file_lock);
4311
4312 /*
4313 * Try to unlock the file in the VFS.
4314 */
Marc Eshelfd85b812006-11-28 16:26:41 -05004315 err = vfs_lock_file(filp, F_SETLK, &file_lock, NULL);
Al Virob8dd7b92006-10-19 23:29:01 -07004316 if (err) {
Marc Eshelfd85b812006-11-28 16:26:41 -05004317 dprintk("NFSD: nfs4_locku: vfs_lock_file failed!\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07004318 goto out_nfserr;
4319 }
4320 /*
4321 * OK, unlock succeeded; the only thing left to do is update the stateid.
4322 */
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04004323 update_stateid(&stp->st_stid.sc_stateid);
4324 memcpy(&locku->lu_stateid, &stp->st_stid.sc_stateid, sizeof(stateid_t));
Linus Torvalds1da177e2005-04-16 15:20:36 -07004325
4326out:
J. Bruce Fields71c3bcd2011-09-27 21:42:29 -04004327 if (!cstate->replay_owner)
4328 nfs4_unlock_state();
Linus Torvalds1da177e2005-04-16 15:20:36 -07004329 return status;
4330
4331out_nfserr:
Al Virob8dd7b92006-10-19 23:29:01 -07004332 status = nfserrno(err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004333 goto out;
4334}
4335
4336/*
4337 * returns
4338 * 1: locks held by lockowner
4339 * 0: no locks held by lockowner
4340 */
4341static int
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004342check_for_locks(struct nfs4_file *filp, struct nfs4_lockowner *lowner)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004343{
4344 struct file_lock **flpp;
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04004345 struct inode *inode = filp->fi_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004346 int status = 0;
4347
Arnd Bergmannb89f4322010-09-18 15:09:31 +02004348 lock_flocks();
Linus Torvalds1da177e2005-04-16 15:20:36 -07004349 for (flpp = &inode->i_flock; *flpp != NULL; flpp = &(*flpp)->fl_next) {
J. Bruce Fields796dadf2006-01-18 17:43:22 -08004350 if ((*flpp)->fl_owner == (fl_owner_t)lowner) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004351 status = 1;
4352 goto out;
J. Bruce Fields796dadf2006-01-18 17:43:22 -08004353 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004354 }
4355out:
Arnd Bergmannb89f4322010-09-18 15:09:31 +02004356 unlock_flocks();
Linus Torvalds1da177e2005-04-16 15:20:36 -07004357 return status;
4358}
4359
Al Virob37ad282006-10-19 23:28:59 -07004360__be32
J.Bruce Fieldsb5914802006-12-13 00:35:38 -08004361nfsd4_release_lockowner(struct svc_rqst *rqstp,
4362 struct nfsd4_compound_state *cstate,
4363 struct nfsd4_release_lockowner *rlockowner)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004364{
4365 clientid_t *clid = &rlockowner->rl_clientid;
NeilBrown3e9e3db2005-06-23 22:04:20 -07004366 struct nfs4_stateowner *sop;
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004367 struct nfs4_lockowner *lo;
J. Bruce Fieldsdcef0412011-09-07 16:06:42 -04004368 struct nfs4_ol_stateid *stp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004369 struct xdr_netobj *owner = &rlockowner->rl_owner;
NeilBrown3e9e3db2005-06-23 22:04:20 -07004370 struct list_head matches;
J. Bruce Fields16bfdaaf2011-11-07 17:23:30 -05004371 unsigned int hashval = ownerstr_hashval(clid->cl_id, owner);
Al Virob37ad282006-10-19 23:28:59 -07004372 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004373
4374 dprintk("nfsd4_release_lockowner clientid: (%08x/%08x):\n",
4375 clid->cl_boot, clid->cl_id);
4376
4377 /* XXX check for lease expiration */
4378
4379 status = nfserr_stale_clientid;
Neil Brown849823c2005-09-13 01:25:36 -07004380 if (STALE_CLIENTID(clid))
Linus Torvalds1da177e2005-04-16 15:20:36 -07004381 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004382
4383 nfs4_lock_state();
4384
NeilBrown3e9e3db2005-06-23 22:04:20 -07004385 status = nfserr_locks_held;
NeilBrown3e9e3db2005-06-23 22:04:20 -07004386 INIT_LIST_HEAD(&matches);
J. Bruce Fields06f1f862011-11-07 16:58:18 -05004387
J. Bruce Fields16bfdaaf2011-11-07 17:23:30 -05004388 list_for_each_entry(sop, &ownerstr_hashtbl[hashval], so_strhash) {
4389 if (sop->so_is_open_owner)
4390 continue;
J. Bruce Fields06f1f862011-11-07 16:58:18 -05004391 if (!same_owner_str(sop, owner, clid))
4392 continue;
4393 list_for_each_entry(stp, &sop->so_stateids,
4394 st_perstateowner) {
4395 lo = lockowner(sop);
4396 if (check_for_locks(stp->st_file, lo))
4397 goto out;
4398 list_add(&lo->lo_list, &matches);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004399 }
NeilBrown3e9e3db2005-06-23 22:04:20 -07004400 }
4401 /* Clients probably won't expect us to return with some (but not all)
4402 * of the lockowner state released; so don't release any until all
4403 * have been checked. */
4404 status = nfs_ok;
NeilBrown0fa822e2005-07-07 17:59:14 -07004405 while (!list_empty(&matches)) {
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004406 lo = list_entry(matches.next, struct nfs4_lockowner,
4407 lo_list);
NeilBrown0fa822e2005-07-07 17:59:14 -07004408 /* unhash_stateowner deletes so_perclient only
4409 * for openowners. */
J. Bruce Fieldsfe0750e2011-07-30 23:33:59 -04004410 list_del(&lo->lo_list);
4411 release_lockowner(lo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004412 }
4413out:
4414 nfs4_unlock_state();
4415 return status;
4416}
4417
4418static inline struct nfs4_client_reclaim *
NeilBrowna55370a2005-06-23 22:03:52 -07004419alloc_reclaim(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004420{
NeilBrowna55370a2005-06-23 22:03:52 -07004421 return kmalloc(sizeof(struct nfs4_client_reclaim), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004422}
4423
NeilBrownc7b9a452005-06-23 22:04:30 -07004424int
Andy Adamsona1bcecd2009-04-03 08:28:05 +03004425nfs4_has_reclaimed_state(const char *name, bool use_exchange_id)
NeilBrownc7b9a452005-06-23 22:04:30 -07004426{
4427 unsigned int strhashval = clientstr_hashval(name);
4428 struct nfs4_client *clp;
4429
J. Bruce Fieldse203d502010-11-24 17:30:54 -05004430 clp = find_confirmed_client_by_str(name, strhashval);
J. Bruce Fields393d8ed2012-03-06 14:43:36 -05004431 if (!clp)
4432 return 0;
Jeff Laytona52d7262012-03-21 09:52:02 -04004433 return test_bit(NFSD4_CLIENT_STABLE, &clp->cl_flags);
NeilBrownc7b9a452005-06-23 22:04:30 -07004434}
4435
Linus Torvalds1da177e2005-04-16 15:20:36 -07004436/*
4437 * failure => all reset bets are off, nfserr_no_grace...
4438 */
NeilBrown190e4fb2005-06-23 22:04:25 -07004439int
4440nfs4_client_to_reclaim(const char *name)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004441{
4442 unsigned int strhashval;
4443 struct nfs4_client_reclaim *crp = NULL;
4444
NeilBrowna55370a2005-06-23 22:03:52 -07004445 dprintk("NFSD nfs4_client_to_reclaim NAME: %.*s\n", HEXDIR_LEN, name);
4446 crp = alloc_reclaim();
Linus Torvalds1da177e2005-04-16 15:20:36 -07004447 if (!crp)
4448 return 0;
NeilBrowna55370a2005-06-23 22:03:52 -07004449 strhashval = clientstr_hashval(name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004450 INIT_LIST_HEAD(&crp->cr_strhash);
4451 list_add(&crp->cr_strhash, &reclaim_str_hashtbl[strhashval]);
NeilBrowna55370a2005-06-23 22:03:52 -07004452 memcpy(crp->cr_recdir, name, HEXDIR_LEN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004453 reclaim_str_hashtbl_size++;
4454 return 1;
4455}
4456
Jeff Layton2a4317c2012-03-21 16:42:43 -04004457void
Linus Torvalds1da177e2005-04-16 15:20:36 -07004458nfs4_release_reclaim(void)
4459{
4460 struct nfs4_client_reclaim *crp = NULL;
4461 int i;
4462
Linus Torvalds1da177e2005-04-16 15:20:36 -07004463 for (i = 0; i < CLIENT_HASH_SIZE; i++) {
4464 while (!list_empty(&reclaim_str_hashtbl[i])) {
4465 crp = list_entry(reclaim_str_hashtbl[i].next,
4466 struct nfs4_client_reclaim, cr_strhash);
4467 list_del(&crp->cr_strhash);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004468 kfree(crp);
4469 reclaim_str_hashtbl_size--;
4470 }
4471 }
4472 BUG_ON(reclaim_str_hashtbl_size);
4473}
4474
4475/*
4476 * called from OPEN, CLAIM_PREVIOUS with a new clientid. */
Jeff Layton2a4317c2012-03-21 16:42:43 -04004477struct nfs4_client_reclaim *
Jeff Laytona52d7262012-03-21 09:52:02 -04004478nfsd4_find_reclaim_client(struct nfs4_client *clp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004479{
4480 unsigned int strhashval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004481 struct nfs4_client_reclaim *crp = NULL;
4482
NeilBrowna55370a2005-06-23 22:03:52 -07004483 dprintk("NFSD: nfs4_find_reclaim_client for %.*s with recdir %s\n",
4484 clp->cl_name.len, clp->cl_name.data,
4485 clp->cl_recdir);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004486
4487 /* find clp->cl_name in reclaim_str_hashtbl */
NeilBrowna55370a2005-06-23 22:03:52 -07004488 strhashval = clientstr_hashval(clp->cl_recdir);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004489 list_for_each_entry(crp, &reclaim_str_hashtbl[strhashval], cr_strhash) {
NeilBrowna55370a2005-06-23 22:03:52 -07004490 if (same_name(crp->cr_recdir, clp->cl_recdir)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004491 return crp;
4492 }
4493 }
4494 return NULL;
4495}
4496
4497/*
4498* Called from OPEN. Look for clientid in reclaim list.
4499*/
Al Virob37ad282006-10-19 23:28:59 -07004500__be32
Linus Torvalds1da177e2005-04-16 15:20:36 -07004501nfs4_check_open_reclaim(clientid_t *clid)
4502{
Jeff Laytona52d7262012-03-21 09:52:02 -04004503 struct nfs4_client *clp;
4504
4505 /* find clientid in conf_id_hashtbl */
4506 clp = find_confirmed_client(clid);
4507 if (clp == NULL)
4508 return nfserr_reclaim_bad;
4509
4510 return nfsd4_client_record_check(clp) ? nfserr_reclaim_bad : nfs_ok;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004511}
4512
Bryan Schumaker65178db2011-11-01 13:35:21 -04004513#ifdef CONFIG_NFSD_FAULT_INJECTION
4514
4515void nfsd_forget_clients(u64 num)
4516{
4517 struct nfs4_client *clp, *next;
4518 int count = 0;
4519
4520 nfs4_lock_state();
4521 list_for_each_entry_safe(clp, next, &client_lru, cl_lru) {
Jeff Layton2a4317c2012-03-21 16:42:43 -04004522 nfsd4_client_record_remove(clp);
Bryan Schumaker65178db2011-11-01 13:35:21 -04004523 expire_client(clp);
4524 if (++count == num)
4525 break;
4526 }
4527 nfs4_unlock_state();
4528
4529 printk(KERN_INFO "NFSD: Forgot %d clients", count);
4530}
4531
4532static void release_lockowner_sop(struct nfs4_stateowner *sop)
4533{
4534 release_lockowner(lockowner(sop));
4535}
4536
4537static void release_openowner_sop(struct nfs4_stateowner *sop)
4538{
4539 release_openowner(openowner(sop));
4540}
4541
J. Bruce Fields353de312011-11-15 19:25:03 -05004542static int nfsd_release_n_owners(u64 num, bool is_open_owner,
Bryan Schumaker65178db2011-11-01 13:35:21 -04004543 void (*release_sop)(struct nfs4_stateowner *))
4544{
4545 int i, count = 0;
4546 struct nfs4_stateowner *sop, *next;
4547
J. Bruce Fields16bfdaaf2011-11-07 17:23:30 -05004548 for (i = 0; i < OWNER_HASH_SIZE; i++) {
4549 list_for_each_entry_safe(sop, next, &ownerstr_hashtbl[i], so_strhash) {
4550 if (sop->so_is_open_owner != is_open_owner)
4551 continue;
Bryan Schumaker65178db2011-11-01 13:35:21 -04004552 release_sop(sop);
4553 if (++count == num)
4554 return count;
4555 }
4556 }
4557 return count;
4558}
4559
4560void nfsd_forget_locks(u64 num)
4561{
4562 int count;
4563
4564 nfs4_lock_state();
J. Bruce Fields16bfdaaf2011-11-07 17:23:30 -05004565 count = nfsd_release_n_owners(num, false, release_lockowner_sop);
Bryan Schumaker65178db2011-11-01 13:35:21 -04004566 nfs4_unlock_state();
4567
4568 printk(KERN_INFO "NFSD: Forgot %d locks", count);
4569}
4570
4571void nfsd_forget_openowners(u64 num)
4572{
4573 int count;
4574
4575 nfs4_lock_state();
J. Bruce Fields16bfdaaf2011-11-07 17:23:30 -05004576 count = nfsd_release_n_owners(num, true, release_openowner_sop);
Bryan Schumaker65178db2011-11-01 13:35:21 -04004577 nfs4_unlock_state();
4578
4579 printk(KERN_INFO "NFSD: Forgot %d open owners", count);
4580}
4581
4582int nfsd_process_n_delegations(u64 num, void (*deleg_func)(struct nfs4_delegation *))
4583{
4584 int i, count = 0;
Bryan Schumaker2d3475c2011-12-14 14:39:56 -05004585 struct nfs4_file *fp, *fnext;
4586 struct nfs4_delegation *dp, *dnext;
Bryan Schumaker65178db2011-11-01 13:35:21 -04004587
4588 for (i = 0; i < FILE_HASH_SIZE; i++) {
Bryan Schumaker2d3475c2011-12-14 14:39:56 -05004589 list_for_each_entry_safe(fp, fnext, &file_hashtbl[i], fi_hash) {
4590 list_for_each_entry_safe(dp, dnext, &fp->fi_delegations, dl_perfile) {
Bryan Schumaker65178db2011-11-01 13:35:21 -04004591 deleg_func(dp);
4592 if (++count == num)
4593 return count;
4594 }
4595 }
4596 }
Bryan Schumaker2d3475c2011-12-14 14:39:56 -05004597
Bryan Schumaker65178db2011-11-01 13:35:21 -04004598 return count;
4599}
4600
4601void nfsd_forget_delegations(u64 num)
4602{
4603 unsigned int count;
4604
4605 nfs4_lock_state();
4606 count = nfsd_process_n_delegations(num, unhash_delegation);
4607 nfs4_unlock_state();
4608
4609 printk(KERN_INFO "NFSD: Forgot %d delegations", count);
4610}
4611
4612void nfsd_recall_delegations(u64 num)
4613{
4614 unsigned int count;
4615
4616 nfs4_lock_state();
4617 spin_lock(&recall_lock);
4618 count = nfsd_process_n_delegations(num, nfsd_break_one_deleg);
4619 spin_unlock(&recall_lock);
4620 nfs4_unlock_state();
4621
4622 printk(KERN_INFO "NFSD: Recalled %d delegations", count);
4623}
4624
4625#endif /* CONFIG_NFSD_FAULT_INJECTION */
4626
NeilBrownac4d8ff22005-06-23 22:03:30 -07004627/* initialization to perform at module load time: */
Linus Torvalds1da177e2005-04-16 15:20:36 -07004628
Bryan Schumaker72083392011-11-01 15:24:59 -04004629void
NeilBrownac4d8ff22005-06-23 22:03:30 -07004630nfs4_state_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004631{
Bryan Schumaker72083392011-11-01 15:24:59 -04004632 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004633
Linus Torvalds1da177e2005-04-16 15:20:36 -07004634 for (i = 0; i < CLIENT_HASH_SIZE; i++) {
4635 INIT_LIST_HEAD(&conf_id_hashtbl[i]);
4636 INIT_LIST_HEAD(&conf_str_hashtbl[i]);
4637 INIT_LIST_HEAD(&unconf_str_hashtbl[i]);
4638 INIT_LIST_HEAD(&unconf_id_hashtbl[i]);
Wang Chen02cb2852009-04-24 15:41:57 +08004639 INIT_LIST_HEAD(&reclaim_str_hashtbl[i]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004640 }
Marc Eshel5282fd72009-04-03 08:27:52 +03004641 for (i = 0; i < SESSION_HASH_SIZE; i++)
4642 INIT_LIST_HEAD(&sessionid_hashtbl[i]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004643 for (i = 0; i < FILE_HASH_SIZE; i++) {
4644 INIT_LIST_HEAD(&file_hashtbl[i]);
4645 }
J. Bruce Fields16bfdaaf2011-11-07 17:23:30 -05004646 for (i = 0; i < OWNER_HASH_SIZE; i++) {
4647 INIT_LIST_HEAD(&ownerstr_hashtbl[i]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004648 }
J. Bruce Fields009673b2011-11-07 17:40:10 -05004649 for (i = 0; i < LOCKOWNER_INO_HASH_SIZE; i++)
4650 INIT_LIST_HEAD(&lockowner_ino_hashtbl[i]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004651 INIT_LIST_HEAD(&close_lru);
4652 INIT_LIST_HEAD(&client_lru);
4653 INIT_LIST_HEAD(&del_recall_lru);
NeilBrownac4d8ff22005-06-23 22:03:30 -07004654 reclaim_str_hashtbl_size = 0;
NeilBrownac4d8ff22005-06-23 22:03:30 -07004655}
4656
Meelap Shahc2f1a552007-07-17 04:04:39 -07004657/*
4658 * Since the lifetime of a delegation isn't limited to that of an open, a
4659 * client may quite reasonably hang on to a delegation as long as it has
4660 * the inode cached. This becomes an obvious problem the first time a
4661 * client's inode cache approaches the size of the server's total memory.
4662 *
4663 * For now we avoid this problem by imposing a hard limit on the number
4664 * of delegations, which varies according to the server's memory size.
4665 */
4666static void
4667set_max_delegations(void)
4668{
4669 /*
4670 * Allow at most 4 delegations per megabyte of RAM. Quick
4671 * estimates suggest that in the worst case (where every delegation
4672 * is for a different inode), a delegation could take about 1.5K,
4673 * giving a worst case usage of about 6% of memory.
4674 */
4675 max_delegations = nr_free_buffer_pages() >> (20 - 2 - PAGE_SHIFT);
4676}
4677
NeilBrownac4d8ff22005-06-23 22:03:30 -07004678/* initialization to perform when the nfsd service is started: */
4679
Jeff Laytona6d6b782012-03-05 11:42:36 -05004680int
4681nfs4_state_start(void)
NeilBrownac4d8ff22005-06-23 22:03:30 -07004682{
J. Bruce Fieldsb5a1a812010-03-03 14:52:55 -05004683 int ret;
4684
Jeff Layton2a4317c2012-03-21 16:42:43 -04004685 /*
4686 * FIXME: For now, we hang most of the pernet global stuff off of
4687 * init_net until nfsd is fully containerized. Eventually, we'll
4688 * need to pass a net pointer into this function, take a reference
4689 * to that instead and then do most of the rest of this on a per-net
4690 * basis.
4691 */
4692 get_net(&init_net);
4693 nfsd4_client_tracking_init(&init_net);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004694 boot_time = get_seconds();
J. Bruce Fieldsaf558e32007-09-06 12:34:25 -04004695 locks_start_grace(&nfsd4_manager);
Jeff Layton33dcc482012-04-10 11:08:48 -04004696 grace_ended = false;
Marc Eshel9a8db972007-07-17 04:04:35 -07004697 printk(KERN_INFO "NFSD: starting %ld-second grace period\n",
J. Bruce Fieldse46b4982010-03-01 19:21:21 -05004698 nfsd4_grace);
J. Bruce Fieldsb5a1a812010-03-03 14:52:55 -05004699 ret = set_callback_cred();
Jeff Laytona6d6b782012-03-05 11:42:36 -05004700 if (ret) {
4701 ret = -ENOMEM;
4702 goto out_recovery;
4703 }
NeilBrown58da2822005-06-23 22:03:19 -07004704 laundry_wq = create_singlethread_workqueue("nfsd4");
Jeff Laytona6d6b782012-03-05 11:42:36 -05004705 if (laundry_wq == NULL) {
4706 ret = -ENOMEM;
4707 goto out_recovery;
4708 }
J. Bruce Fieldsb5a1a812010-03-03 14:52:55 -05004709 ret = nfsd4_create_callback_queue();
4710 if (ret)
4711 goto out_free_laundry;
J. Bruce Fieldse46b4982010-03-01 19:21:21 -05004712 queue_delayed_work(laundry_wq, &laundromat_work, nfsd4_grace * HZ);
Meelap Shahc2f1a552007-07-17 04:04:39 -07004713 set_max_delegations();
J. Bruce Fieldsb5a1a812010-03-03 14:52:55 -05004714 return 0;
4715out_free_laundry:
4716 destroy_workqueue(laundry_wq);
Jeff Laytona6d6b782012-03-05 11:42:36 -05004717out_recovery:
Jeff Layton2a4317c2012-03-21 16:42:43 -04004718 nfsd4_client_tracking_exit(&init_net);
4719 put_net(&init_net);
J. Bruce Fieldsb5a1a812010-03-03 14:52:55 -05004720 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004721}
4722
Linus Torvalds1da177e2005-04-16 15:20:36 -07004723static void
4724__nfs4_state_shutdown(void)
4725{
4726 int i;
4727 struct nfs4_client *clp = NULL;
4728 struct nfs4_delegation *dp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004729 struct list_head *pos, *next, reaplist;
4730
Linus Torvalds1da177e2005-04-16 15:20:36 -07004731 for (i = 0; i < CLIENT_HASH_SIZE; i++) {
4732 while (!list_empty(&conf_id_hashtbl[i])) {
4733 clp = list_entry(conf_id_hashtbl[i].next, struct nfs4_client, cl_idhash);
4734 expire_client(clp);
4735 }
4736 while (!list_empty(&unconf_str_hashtbl[i])) {
4737 clp = list_entry(unconf_str_hashtbl[i].next, struct nfs4_client, cl_strhash);
4738 expire_client(clp);
4739 }
4740 }
4741 INIT_LIST_HEAD(&reaplist);
4742 spin_lock(&recall_lock);
4743 list_for_each_safe(pos, next, &del_recall_lru) {
4744 dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
4745 list_move(&dp->dl_recall_lru, &reaplist);
4746 }
4747 spin_unlock(&recall_lock);
4748 list_for_each_safe(pos, next, &reaplist) {
4749 dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004750 unhash_delegation(dp);
4751 }
4752
Jeff Layton2a4317c2012-03-21 16:42:43 -04004753 nfsd4_client_tracking_exit(&init_net);
4754 put_net(&init_net);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004755}
4756
4757void
4758nfs4_state_shutdown(void)
4759{
Tejun Heoafe2c512010-12-14 16:21:17 +01004760 cancel_delayed_work_sync(&laundromat_work);
NeilBrown5e8d5c22006-04-10 22:55:37 -07004761 destroy_workqueue(laundry_wq);
J. Bruce Fields2c5e7612008-11-20 14:36:17 -06004762 locks_end_grace(&nfsd4_manager);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004763 nfs4_lock_state();
Linus Torvalds1da177e2005-04-16 15:20:36 -07004764 __nfs4_state_shutdown();
Linus Torvalds1da177e2005-04-16 15:20:36 -07004765 nfs4_unlock_state();
J. Bruce Fieldsc3935e32010-06-04 16:42:08 -04004766 nfsd4_destroy_callback_queue();
Linus Torvalds1da177e2005-04-16 15:20:36 -07004767}
Tigran Mkrtchyan8b704842012-02-13 22:55:24 +01004768
4769static void
4770get_stateid(struct nfsd4_compound_state *cstate, stateid_t *stateid)
4771{
Tigran Mkrtchyan37c593c2012-02-13 22:55:32 +01004772 if (HAS_STATE_ID(cstate, CURRENT_STATE_ID_FLAG) && CURRENT_STATEID(stateid))
4773 memcpy(stateid, &cstate->current_stateid, sizeof(stateid_t));
Tigran Mkrtchyan8b704842012-02-13 22:55:24 +01004774}
4775
4776static void
4777put_stateid(struct nfsd4_compound_state *cstate, stateid_t *stateid)
4778{
Tigran Mkrtchyan37c593c2012-02-13 22:55:32 +01004779 if (cstate->minorversion) {
4780 memcpy(&cstate->current_stateid, stateid, sizeof(stateid_t));
4781 SET_STATE_ID(cstate, CURRENT_STATE_ID_FLAG);
4782 }
4783}
4784
4785void
4786clear_current_stateid(struct nfsd4_compound_state *cstate)
4787{
4788 CLEAR_STATE_ID(cstate, CURRENT_STATE_ID_FLAG);
Tigran Mkrtchyan8b704842012-02-13 22:55:24 +01004789}
4790
Tigran Mkrtchyan62cd4a52012-02-13 22:55:25 +01004791/*
4792 * functions to set current state id
4793 */
Tigran Mkrtchyan8b704842012-02-13 22:55:24 +01004794void
Tigran Mkrtchyan9428fe12012-02-13 22:55:31 +01004795nfsd4_set_opendowngradestateid(struct nfsd4_compound_state *cstate, struct nfsd4_open_downgrade *odp)
4796{
4797 put_stateid(cstate, &odp->od_stateid);
4798}
4799
4800void
Tigran Mkrtchyan8b704842012-02-13 22:55:24 +01004801nfsd4_set_openstateid(struct nfsd4_compound_state *cstate, struct nfsd4_open *open)
4802{
4803 put_stateid(cstate, &open->op_stateid);
4804}
4805
4806void
Tigran Mkrtchyan62cd4a52012-02-13 22:55:25 +01004807nfsd4_set_closestateid(struct nfsd4_compound_state *cstate, struct nfsd4_close *close)
4808{
4809 put_stateid(cstate, &close->cl_stateid);
4810}
4811
4812void
4813nfsd4_set_lockstateid(struct nfsd4_compound_state *cstate, struct nfsd4_lock *lock)
4814{
4815 put_stateid(cstate, &lock->lk_resp_stateid);
4816}
4817
4818/*
4819 * functions to consume current state id
4820 */
Tigran Mkrtchyan1e97b512012-02-13 22:55:30 +01004821
4822void
Tigran Mkrtchyan9428fe12012-02-13 22:55:31 +01004823nfsd4_get_opendowngradestateid(struct nfsd4_compound_state *cstate, struct nfsd4_open_downgrade *odp)
4824{
4825 get_stateid(cstate, &odp->od_stateid);
4826}
4827
4828void
4829nfsd4_get_delegreturnstateid(struct nfsd4_compound_state *cstate, struct nfsd4_delegreturn *drp)
4830{
4831 get_stateid(cstate, &drp->dr_stateid);
4832}
4833
4834void
Tigran Mkrtchyan1e97b512012-02-13 22:55:30 +01004835nfsd4_get_freestateid(struct nfsd4_compound_state *cstate, struct nfsd4_free_stateid *fsp)
4836{
4837 get_stateid(cstate, &fsp->fr_stateid);
4838}
4839
4840void
4841nfsd4_get_setattrstateid(struct nfsd4_compound_state *cstate, struct nfsd4_setattr *setattr)
4842{
4843 get_stateid(cstate, &setattr->sa_stateid);
4844}
4845
Tigran Mkrtchyan62cd4a52012-02-13 22:55:25 +01004846void
Tigran Mkrtchyan8b704842012-02-13 22:55:24 +01004847nfsd4_get_closestateid(struct nfsd4_compound_state *cstate, struct nfsd4_close *close)
4848{
4849 get_stateid(cstate, &close->cl_stateid);
4850}
4851
4852void
Tigran Mkrtchyan62cd4a52012-02-13 22:55:25 +01004853nfsd4_get_lockustateid(struct nfsd4_compound_state *cstate, struct nfsd4_locku *locku)
Tigran Mkrtchyan8b704842012-02-13 22:55:24 +01004854{
Tigran Mkrtchyan62cd4a52012-02-13 22:55:25 +01004855 get_stateid(cstate, &locku->lu_stateid);
Tigran Mkrtchyan8b704842012-02-13 22:55:24 +01004856}
Tigran Mkrtchyan30813e22012-02-13 22:55:26 +01004857
4858void
4859nfsd4_get_readstateid(struct nfsd4_compound_state *cstate, struct nfsd4_read *read)
4860{
4861 get_stateid(cstate, &read->rd_stateid);
4862}
4863
4864void
4865nfsd4_get_writestateid(struct nfsd4_compound_state *cstate, struct nfsd4_write *write)
4866{
4867 get_stateid(cstate, &write->wr_stateid);
4868}