blob: e98f3c2e9492a9d2dd3e86e6e443e924c9f04187 [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>
Olga Kornievskaia68e76ad2008-12-23 16:17:15 -050040#include <linux/sunrpc/svcauth_gss.h>
Jeff Layton363168b2009-08-14 12:57:56 -040041#include <linux/sunrpc/clnt.h>
Boaz Harrosh9a74af22009-12-03 20:30:56 +020042#include "xdr4.h"
J. Bruce Fields0a3adad2009-11-04 18:12:35 -050043#include "vfs.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070044
45#define NFSDDBG_FACILITY NFSDDBG_PROC
46
47/* Globals */
J. Bruce Fieldscf07d2e2010-02-28 23:20:19 -050048time_t nfsd4_lease = 90; /* default lease time */
J. Bruce Fieldsefc4bb4f2010-03-02 11:04:06 -050049time_t nfsd4_grace = 90;
NeilBrownfd39ca92005-06-23 22:04:03 -070050static time_t boot_time;
Linus Torvalds1da177e2005-04-16 15:20:36 -070051static u32 current_ownerid = 1;
52static u32 current_fileid = 1;
53static u32 current_delegid = 1;
NeilBrownfd39ca92005-06-23 22:04:03 -070054static stateid_t zerostateid; /* bits all 0 */
55static stateid_t onestateid; /* bits all 1 */
Andy Adamsonec6b5d72009-04-03 08:28:28 +030056static u64 current_sessionid = 1;
NeilBrownfd39ca92005-06-23 22:04:03 -070057
58#define ZERO_STATEID(stateid) (!memcmp((stateid), &zerostateid, sizeof(stateid_t)))
59#define ONE_STATEID(stateid) (!memcmp((stateid), &onestateid, sizeof(stateid_t)))
Linus Torvalds1da177e2005-04-16 15:20:36 -070060
Linus Torvalds1da177e2005-04-16 15:20:36 -070061/* forward declarations */
NeilBrownfd39ca92005-06-23 22:04:03 -070062static struct nfs4_stateid * find_stateid(stateid_t *stid, int flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -070063static struct nfs4_delegation * find_delegation_stateid(struct inode *ino, stateid_t *stid);
NeilBrown0964a3d2005-06-23 22:04:32 -070064static char user_recovery_dirname[PATH_MAX] = "/var/lib/nfs/v4recovery";
65static void nfs4_set_recdir(char *recdir);
Linus Torvalds1da177e2005-04-16 15:20:36 -070066
J. Bruce Fields8b671b82009-02-22 14:51:34 -080067/* Locking: */
68
69/* Currently used for almost all code touching nfsv4 state: */
Ingo Molnar353ab6e2006-03-26 01:37:12 -080070static DEFINE_MUTEX(client_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070071
J. Bruce Fields8b671b82009-02-22 14:51:34 -080072/*
73 * Currently used for the del_recall_lru and file hash table. In an
74 * effort to decrease the scope of the client_mutex, this spinlock may
75 * eventually cover more:
76 */
77static DEFINE_SPINLOCK(recall_lock);
78
Christoph Lametere18b8902006-12-06 20:33:20 -080079static struct kmem_cache *stateowner_slab = NULL;
80static struct kmem_cache *file_slab = NULL;
81static struct kmem_cache *stateid_slab = NULL;
82static struct kmem_cache *deleg_slab = NULL;
NeilBrowne60d4392005-06-23 22:03:01 -070083
Linus Torvalds1da177e2005-04-16 15:20:36 -070084void
85nfs4_lock_state(void)
86{
Ingo Molnar353ab6e2006-03-26 01:37:12 -080087 mutex_lock(&client_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070088}
89
90void
91nfs4_unlock_state(void)
92{
Ingo Molnar353ab6e2006-03-26 01:37:12 -080093 mutex_unlock(&client_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070094}
95
96static inline u32
97opaque_hashval(const void *ptr, int nbytes)
98{
99 unsigned char *cptr = (unsigned char *) ptr;
100
101 u32 x = 0;
102 while (nbytes--) {
103 x *= 37;
104 x += *cptr++;
105 }
106 return x;
107}
108
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109static struct list_head del_recall_lru;
110
NeilBrown13cd2182005-06-23 22:03:10 -0700111static inline void
112put_nfs4_file(struct nfs4_file *fi)
113{
J. Bruce Fields8b671b82009-02-22 14:51:34 -0800114 if (atomic_dec_and_lock(&fi->fi_ref, &recall_lock)) {
115 list_del(&fi->fi_hash);
116 spin_unlock(&recall_lock);
117 iput(fi->fi_inode);
118 kmem_cache_free(file_slab, fi);
119 }
NeilBrown13cd2182005-06-23 22:03:10 -0700120}
121
122static inline void
123get_nfs4_file(struct nfs4_file *fi)
124{
J. Bruce Fields8b671b82009-02-22 14:51:34 -0800125 atomic_inc(&fi->fi_ref);
NeilBrown13cd2182005-06-23 22:03:10 -0700126}
127
NeilBrownef0f3392006-04-10 22:55:41 -0700128static int num_delegations;
Meelap Shahc2f1a552007-07-17 04:04:39 -0700129unsigned int max_delegations;
NeilBrownef0f3392006-04-10 22:55:41 -0700130
131/*
132 * Open owner state (share locks)
133 */
134
135/* hash tables for nfs4_stateowner */
136#define OWNER_HASH_BITS 8
137#define OWNER_HASH_SIZE (1 << OWNER_HASH_BITS)
138#define OWNER_HASH_MASK (OWNER_HASH_SIZE - 1)
139
140#define ownerid_hashval(id) \
141 ((id) & OWNER_HASH_MASK)
142#define ownerstr_hashval(clientid, ownername) \
143 (((clientid) + opaque_hashval((ownername.data), (ownername.len))) & OWNER_HASH_MASK)
144
145static struct list_head ownerid_hashtbl[OWNER_HASH_SIZE];
146static struct list_head ownerstr_hashtbl[OWNER_HASH_SIZE];
147
148/* hash table for nfs4_file */
149#define FILE_HASH_BITS 8
150#define FILE_HASH_SIZE (1 << FILE_HASH_BITS)
Shan Wei35079582011-01-14 17:35:59 +0800151
NeilBrownef0f3392006-04-10 22:55:41 -0700152/* hash table for (open)nfs4_stateid */
153#define STATEID_HASH_BITS 10
154#define STATEID_HASH_SIZE (1 << STATEID_HASH_BITS)
155#define STATEID_HASH_MASK (STATEID_HASH_SIZE - 1)
156
157#define file_hashval(x) \
158 hash_ptr(x, FILE_HASH_BITS)
159#define stateid_hashval(owner_id, file_id) \
160 (((owner_id) + (file_id)) & STATEID_HASH_MASK)
161
162static struct list_head file_hashtbl[FILE_HASH_SIZE];
163static struct list_head stateid_hashtbl[STATEID_HASH_SIZE];
164
J. Bruce Fields998db522010-08-07 09:21:41 -0400165static void __nfs4_file_get_access(struct nfs4_file *fp, int oflag)
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400166{
167 BUG_ON(!(fp->fi_fds[oflag] || fp->fi_fds[O_RDWR]));
168 atomic_inc(&fp->fi_access[oflag]);
169}
170
J. Bruce Fields998db522010-08-07 09:21:41 -0400171static void nfs4_file_get_access(struct nfs4_file *fp, int oflag)
172{
173 if (oflag == O_RDWR) {
174 __nfs4_file_get_access(fp, O_RDONLY);
175 __nfs4_file_get_access(fp, O_WRONLY);
176 } else
177 __nfs4_file_get_access(fp, oflag);
178}
179
180static void nfs4_file_put_fd(struct nfs4_file *fp, int oflag)
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400181{
182 if (fp->fi_fds[oflag]) {
183 fput(fp->fi_fds[oflag]);
184 fp->fi_fds[oflag] = NULL;
185 }
186}
187
J. Bruce Fields998db522010-08-07 09:21:41 -0400188static void __nfs4_file_put_access(struct nfs4_file *fp, int oflag)
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400189{
190 if (atomic_dec_and_test(&fp->fi_access[oflag])) {
191 nfs4_file_put_fd(fp, O_RDWR);
192 nfs4_file_put_fd(fp, oflag);
193 }
194}
195
J. Bruce Fields998db522010-08-07 09:21:41 -0400196static void nfs4_file_put_access(struct nfs4_file *fp, int oflag)
197{
198 if (oflag == O_RDWR) {
199 __nfs4_file_put_access(fp, O_RDONLY);
200 __nfs4_file_put_access(fp, O_WRONLY);
201 } else
202 __nfs4_file_put_access(fp, oflag);
203}
204
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205static struct nfs4_delegation *
206alloc_init_deleg(struct nfs4_client *clp, struct nfs4_stateid *stp, struct svc_fh *current_fh, u32 type)
207{
208 struct nfs4_delegation *dp;
209 struct nfs4_file *fp = stp->st_file;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210
211 dprintk("NFSD alloc_init_deleg\n");
J. Bruce Fieldsc3e48082010-07-28 10:08:57 -0400212 /*
213 * Major work on the lease subsystem (for example, to support
214 * calbacks on stat) will be required before we can support
215 * write delegations properly.
216 */
217 if (type != NFS4_OPEN_DELEGATE_READ)
218 return NULL;
Meelap Shah47f99402007-07-17 04:04:40 -0700219 if (fp->fi_had_conflict)
220 return NULL;
Meelap Shahc2f1a552007-07-17 04:04:39 -0700221 if (num_delegations > max_delegations)
NeilBrownef0f3392006-04-10 22:55:41 -0700222 return NULL;
NeilBrown5b2d21c2005-06-23 22:03:04 -0700223 dp = kmem_cache_alloc(deleg_slab, GFP_KERNEL);
224 if (dp == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225 return dp;
NeilBrownef0f3392006-04-10 22:55:41 -0700226 num_delegations++;
NeilBrownea1da632005-06-23 22:04:17 -0700227 INIT_LIST_HEAD(&dp->dl_perfile);
228 INIT_LIST_HEAD(&dp->dl_perclnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229 INIT_LIST_HEAD(&dp->dl_recall_lru);
230 dp->dl_client = clp;
NeilBrown13cd2182005-06-23 22:03:10 -0700231 get_nfs4_file(fp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232 dp->dl_file = fp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233 dp->dl_type = type;
J. Bruce Fieldse4e83ea2010-04-22 16:21:39 -0400234 dp->dl_stateid.si_boot = boot_time;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700235 dp->dl_stateid.si_stateownerid = current_delegid++;
236 dp->dl_stateid.si_fileid = 0;
237 dp->dl_stateid.si_generation = 0;
J. Bruce Fields6c02eaa2009-02-02 17:30:51 -0500238 fh_copy_shallow(&dp->dl_fh, &current_fh->fh_handle);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700239 dp->dl_time = 0;
240 atomic_set(&dp->dl_count, 1);
J. Bruce Fieldsb5a1a812010-03-03 14:52:55 -0500241 INIT_WORK(&dp->dl_recall.cb_work, nfsd4_do_callback_rpc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242 return dp;
243}
244
245void
246nfs4_put_delegation(struct nfs4_delegation *dp)
247{
248 if (atomic_dec_and_test(&dp->dl_count)) {
249 dprintk("NFSD: freeing dp %p\n",dp);
NeilBrown13cd2182005-06-23 22:03:10 -0700250 put_nfs4_file(dp->dl_file);
NeilBrown5b2d21c2005-06-23 22:03:04 -0700251 kmem_cache_free(deleg_slab, dp);
NeilBrownef0f3392006-04-10 22:55:41 -0700252 num_delegations--;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253 }
254}
255
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -0500256static void nfs4_put_deleg_lease(struct nfs4_file *fp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257{
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -0500258 if (atomic_dec_and_test(&fp->fi_delegees)) {
259 vfs_setlease(fp->fi_deleg_file, F_UNLCK, &fp->fi_lease);
260 fp->fi_lease = NULL;
J. Bruce Fields4ee63622011-04-15 18:08:26 -0400261 fput(fp->fi_deleg_file);
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -0500262 fp->fi_deleg_file = NULL;
263 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264}
265
266/* Called under the state lock. */
267static void
268unhash_delegation(struct nfs4_delegation *dp)
269{
NeilBrownea1da632005-06-23 22:04:17 -0700270 list_del_init(&dp->dl_perclnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271 spin_lock(&recall_lock);
J. Bruce Fields5d926e82011-02-07 16:53:46 -0500272 list_del_init(&dp->dl_perfile);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273 list_del_init(&dp->dl_recall_lru);
274 spin_unlock(&recall_lock);
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -0500275 nfs4_put_deleg_lease(dp->dl_file);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276 nfs4_put_delegation(dp);
277}
278
279/*
280 * SETCLIENTID state
281 */
282
Benny Halevy36acb662010-05-12 00:13:04 +0300283/* client_lock protects the client lru list and session hash table */
Benny Halevy9089f1b2010-05-12 00:12:26 +0300284static DEFINE_SPINLOCK(client_lock);
285
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286/* Hash tables for nfs4_clientid state */
287#define CLIENT_HASH_BITS 4
288#define CLIENT_HASH_SIZE (1 << CLIENT_HASH_BITS)
289#define CLIENT_HASH_MASK (CLIENT_HASH_SIZE - 1)
290
291#define clientid_hashval(id) \
292 ((id) & CLIENT_HASH_MASK)
NeilBrowna55370a2005-06-23 22:03:52 -0700293#define clientstr_hashval(name) \
294 (opaque_hashval((name), 8) & CLIENT_HASH_MASK)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295/*
296 * reclaim_str_hashtbl[] holds known client info from previous reset/reboot
297 * used in reboot/reset lease grace period processing
298 *
299 * conf_id_hashtbl[], and conf_str_hashtbl[] hold confirmed
300 * setclientid_confirmed info.
301 *
302 * unconf_str_hastbl[] and unconf_id_hashtbl[] hold unconfirmed
303 * setclientid info.
304 *
305 * client_lru holds client queue ordered by nfs4_client.cl_time
306 * for lease renewal.
307 *
308 * close_lru holds (open) stateowner queue ordered by nfs4_stateowner.so_time
309 * for last close replay.
310 */
311static struct list_head reclaim_str_hashtbl[CLIENT_HASH_SIZE];
312static int reclaim_str_hashtbl_size = 0;
313static struct list_head conf_id_hashtbl[CLIENT_HASH_SIZE];
314static struct list_head conf_str_hashtbl[CLIENT_HASH_SIZE];
315static struct list_head unconf_str_hashtbl[CLIENT_HASH_SIZE];
316static struct list_head unconf_id_hashtbl[CLIENT_HASH_SIZE];
317static struct list_head client_lru;
318static struct list_head close_lru;
319
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400320/*
321 * We store the NONE, READ, WRITE, and BOTH bits separately in the
322 * st_{access,deny}_bmap field of the stateid, in order to track not
323 * only what share bits are currently in force, but also what
324 * combinations of share bits previous opens have used. This allows us
325 * to enforce the recommendation of rfc 3530 14.2.19 that the server
326 * return an error if the client attempt to downgrade to a combination
327 * of share bits not explicable by closing some of its previous opens.
328 *
329 * XXX: This enforcement is actually incomplete, since we don't keep
330 * track of access/deny bit combinations; so, e.g., we allow:
331 *
332 * OPEN allow read, deny write
333 * OPEN allow both, deny none
334 * DOWNGRADE allow read, deny none
335 *
336 * which we should reject.
337 */
338static void
339set_access(unsigned int *access, unsigned long bmap) {
340 int i;
341
342 *access = 0;
343 for (i = 1; i < 4; i++) {
344 if (test_bit(i, &bmap))
345 *access |= i;
346 }
347}
348
349static void
350set_deny(unsigned int *deny, unsigned long bmap) {
351 int i;
352
353 *deny = 0;
354 for (i = 0; i < 4; i++) {
355 if (test_bit(i, &bmap))
356 *deny |= i ;
357 }
358}
359
360static int
361test_share(struct nfs4_stateid *stp, struct nfsd4_open *open) {
362 unsigned int access, deny;
363
364 set_access(&access, stp->st_access_bmap);
365 set_deny(&deny, stp->st_deny_bmap);
366 if ((access & open->op_share_deny) || (deny & open->op_share_access))
367 return 0;
368 return 1;
369}
370
371static int nfs4_access_to_omode(u32 access)
372{
J. Bruce Fields8f34a432010-09-02 15:23:16 -0400373 switch (access & NFS4_SHARE_ACCESS_BOTH) {
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400374 case NFS4_SHARE_ACCESS_READ:
375 return O_RDONLY;
376 case NFS4_SHARE_ACCESS_WRITE:
377 return O_WRONLY;
378 case NFS4_SHARE_ACCESS_BOTH:
379 return O_RDWR;
380 }
381 BUG();
382}
383
384static int nfs4_access_bmap_to_omode(struct nfs4_stateid *stp)
385{
386 unsigned int access;
387
388 set_access(&access, stp->st_access_bmap);
389 return nfs4_access_to_omode(access);
390}
391
J. Bruce Fields529d7b22011-03-02 23:48:33 -0500392static void unhash_generic_stateid(struct nfs4_stateid *stp)
393{
394 list_del(&stp->st_hash);
395 list_del(&stp->st_perfile);
396 list_del(&stp->st_perstateowner);
397}
398
399static void free_generic_stateid(struct nfs4_stateid *stp)
400{
J. Bruce Fields23fcf2e2011-03-28 15:15:09 +0800401 int oflag;
J. Bruce Fields0997b172011-03-02 18:01:35 -0500402
J. Bruce Fields23fcf2e2011-03-28 15:15:09 +0800403 if (stp->st_access_bmap) {
404 oflag = nfs4_access_bmap_to_omode(stp);
405 nfs4_file_put_access(stp->st_file, oflag);
J. Bruce Fields23fcf2e2011-03-28 15:15:09 +0800406 }
OGAWA Hirofumia96e5b92011-04-18 11:48:55 -0400407 put_nfs4_file(stp->st_file);
J. Bruce Fields529d7b22011-03-02 23:48:33 -0500408 kmem_cache_free(stateid_slab, stp);
409}
410
411static void release_lock_stateid(struct nfs4_stateid *stp)
412{
413 struct file *file;
414
415 unhash_generic_stateid(stp);
416 file = find_any_file(stp->st_file);
417 if (file)
418 locks_remove_posix(file, (fl_owner_t)stp->st_stateowner);
419 free_generic_stateid(stp);
420}
421
422static void unhash_lockowner(struct nfs4_stateowner *sop)
423{
424 struct nfs4_stateid *stp;
425
426 list_del(&sop->so_idhash);
427 list_del(&sop->so_strhash);
428 list_del(&sop->so_perstateid);
429 while (!list_empty(&sop->so_stateids)) {
430 stp = list_first_entry(&sop->so_stateids,
431 struct nfs4_stateid, st_perstateowner);
432 release_lock_stateid(stp);
433 }
434}
435
436static void release_lockowner(struct nfs4_stateowner *sop)
437{
438 unhash_lockowner(sop);
439 nfs4_put_stateowner(sop);
440}
441
442static void
443release_stateid_lockowners(struct nfs4_stateid *open_stp)
444{
445 struct nfs4_stateowner *lock_sop;
446
447 while (!list_empty(&open_stp->st_lockowners)) {
448 lock_sop = list_entry(open_stp->st_lockowners.next,
449 struct nfs4_stateowner, so_perstateid);
450 /* list_del(&open_stp->st_lockowners); */
451 BUG_ON(lock_sop->so_is_open_owner);
452 release_lockowner(lock_sop);
453 }
454}
455
J. Bruce Fields22839632009-01-11 14:27:17 -0500456static void release_open_stateid(struct nfs4_stateid *stp)
457{
458 unhash_generic_stateid(stp);
459 release_stateid_lockowners(stp);
J. Bruce Fields22839632009-01-11 14:27:17 -0500460 free_generic_stateid(stp);
461}
462
J. Bruce Fieldsf044ff82009-01-11 15:24:04 -0500463static void unhash_openowner(struct nfs4_stateowner *sop)
J. Bruce Fieldsf1d110c2009-01-11 14:37:31 -0500464{
465 struct nfs4_stateid *stp;
466
467 list_del(&sop->so_idhash);
468 list_del(&sop->so_strhash);
J. Bruce Fieldsf044ff82009-01-11 15:24:04 -0500469 list_del(&sop->so_perclient);
470 list_del(&sop->so_perstateid); /* XXX: necessary? */
J. Bruce Fieldsf1d110c2009-01-11 14:37:31 -0500471 while (!list_empty(&sop->so_stateids)) {
J. Bruce Fieldsf044ff82009-01-11 15:24:04 -0500472 stp = list_first_entry(&sop->so_stateids,
473 struct nfs4_stateid, st_perstateowner);
474 release_open_stateid(stp);
J. Bruce Fieldsf1d110c2009-01-11 14:37:31 -0500475 }
476}
477
J. Bruce Fieldsf044ff82009-01-11 15:24:04 -0500478static void release_openowner(struct nfs4_stateowner *sop)
J. Bruce Fieldsf1d110c2009-01-11 14:37:31 -0500479{
J. Bruce Fieldsf044ff82009-01-11 15:24:04 -0500480 unhash_openowner(sop);
J. Bruce Fieldsf1d110c2009-01-11 14:37:31 -0500481 list_del(&sop->so_close_lru);
482 nfs4_put_stateowner(sop);
483}
484
Marc Eshel5282fd72009-04-03 08:27:52 +0300485#define SESSION_HASH_SIZE 512
486static struct list_head sessionid_hashtbl[SESSION_HASH_SIZE];
487
488static inline int
489hash_sessionid(struct nfs4_sessionid *sessionid)
490{
491 struct nfsd4_sessionid *sid = (struct nfsd4_sessionid *)sessionid;
492
493 return sid->sequence % SESSION_HASH_SIZE;
494}
495
496static inline void
497dump_sessionid(const char *fn, struct nfs4_sessionid *sessionid)
498{
499 u32 *ptr = (u32 *)(&sessionid->data[0]);
500 dprintk("%s: %u:%u:%u:%u\n", fn, ptr[0], ptr[1], ptr[2], ptr[3]);
501}
502
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300503static void
504gen_sessionid(struct nfsd4_session *ses)
505{
506 struct nfs4_client *clp = ses->se_client;
507 struct nfsd4_sessionid *sid;
508
509 sid = (struct nfsd4_sessionid *)ses->se_sessionid.data;
510 sid->clientid = clp->cl_clientid;
511 sid->sequence = current_sessionid++;
512 sid->reserved = 0;
513}
514
515/*
Andy Adamsona6496372009-08-28 08:45:01 -0400516 * The protocol defines ca_maxresponssize_cached to include the size of
517 * the rpc header, but all we need to cache is the data starting after
518 * the end of the initial SEQUENCE operation--the rest we regenerate
519 * each time. Therefore we can advertise a ca_maxresponssize_cached
520 * value that is the number of bytes in our cache plus a few additional
521 * bytes. In order to stay on the safe side, and not promise more than
522 * we can cache, those additional bytes must be the minimum possible: 24
523 * bytes of rpc header (xid through accept state, with AUTH_NULL
524 * verifier), 12 for the compound header (with zero-length tag), and 44
525 * for the SEQUENCE op response:
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300526 */
Andy Adamsona6496372009-08-28 08:45:01 -0400527#define NFSD_MIN_HDR_SEQ_SZ (24 + 12 + 44)
528
Andy Adamson557ce262009-08-28 08:45:04 -0400529static void
530free_session_slots(struct nfsd4_session *ses)
531{
532 int i;
533
534 for (i = 0; i < ses->se_fchannel.maxreqs; i++)
535 kfree(ses->se_slots[i]);
536}
537
J. Bruce Fieldsefe0cb62009-10-24 20:52:16 -0400538/*
539 * We don't actually need to cache the rpc and session headers, so we
540 * can allocate a little less for each slot:
541 */
542static inline int slot_bytes(struct nfsd4_channel_attrs *ca)
543{
544 return ca->maxresp_cached - NFSD_MIN_HDR_SEQ_SZ;
545}
546
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400547static int nfsd4_sanitize_slot_size(u32 size)
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300548{
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400549 size -= NFSD_MIN_HDR_SEQ_SZ; /* We don't cache the rpc header */
550 size = min_t(u32, size, NFSD_SLOT_CACHE_SIZE);
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300551
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400552 return size;
553}
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300554
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400555/*
556 * XXX: If we run out of reserved DRC memory we could (up to a point)
557 * re-negotiate active sessions and reduce their slot usage to make
558 * rooom for new connections. For now we just fail the create session.
559 */
560static int nfsd4_get_drc_mem(int slotsize, u32 num)
561{
562 int avail;
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300563
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400564 num = min_t(u32, num, NFSD_MAX_SLOTS_PER_SESSION);
Andy Adamson557ce262009-08-28 08:45:04 -0400565
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400566 spin_lock(&nfsd_drc_lock);
567 avail = min_t(int, NFSD_MAX_MEM_PER_SESSION,
568 nfsd_drc_max_mem - nfsd_drc_mem_used);
569 num = min_t(int, num, avail / slotsize);
570 nfsd_drc_mem_used += num * slotsize;
571 spin_unlock(&nfsd_drc_lock);
572
573 return num;
574}
575
576static void nfsd4_put_drc_mem(int slotsize, int num)
577{
578 spin_lock(&nfsd_drc_lock);
579 nfsd_drc_mem_used -= slotsize * num;
580 spin_unlock(&nfsd_drc_lock);
581}
582
583static struct nfsd4_session *alloc_session(int slotsize, int numslots)
584{
585 struct nfsd4_session *new;
586 int mem, i;
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300587
J. Bruce Fieldsc23753d2010-09-27 16:22:30 -0400588 BUILD_BUG_ON(NFSD_MAX_SLOTS_PER_SESSION * sizeof(struct nfsd4_slot *)
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400589 + sizeof(struct nfsd4_session) > PAGE_SIZE);
590 mem = numslots * sizeof(struct nfsd4_slot *);
Andy Adamson557ce262009-08-28 08:45:04 -0400591
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400592 new = kzalloc(sizeof(*new) + mem, GFP_KERNEL);
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300593 if (!new)
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400594 return NULL;
Andy Adamson557ce262009-08-28 08:45:04 -0400595 /* allocate each struct nfsd4_slot and data cache in one piece */
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400596 for (i = 0; i < numslots; i++) {
597 mem = sizeof(struct nfsd4_slot) + slotsize;
598 new->se_slots[i] = kzalloc(mem, GFP_KERNEL);
599 if (!new->se_slots[i])
Andy Adamson557ce262009-08-28 08:45:04 -0400600 goto out_free;
Andy Adamson557ce262009-08-28 08:45:04 -0400601 }
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400602 return new;
603out_free:
604 while (i--)
605 kfree(new->se_slots[i]);
606 kfree(new);
607 return NULL;
608}
609
610static void init_forechannel_attrs(struct nfsd4_channel_attrs *new, struct nfsd4_channel_attrs *req, int numslots, int slotsize)
611{
612 u32 maxrpc = nfsd_serv->sv_max_mesg;
613
614 new->maxreqs = numslots;
Mi Jinlongd2b21742011-03-10 17:43:37 +0800615 new->maxresp_cached = min_t(u32, req->maxresp_cached,
616 slotsize + NFSD_MIN_HDR_SEQ_SZ);
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400617 new->maxreq_sz = min_t(u32, req->maxreq_sz, maxrpc);
618 new->maxresp_sz = min_t(u32, req->maxresp_sz, maxrpc);
619 new->maxops = min_t(u32, req->maxops, NFSD_MAX_OPS_PER_COMPOUND);
620}
621
J. Bruce Fields19cf5c02010-06-06 18:37:16 -0400622static void free_conn(struct nfsd4_conn *c)
623{
624 svc_xprt_put(c->cn_xprt);
625 kfree(c);
626}
627
628static void nfsd4_conn_lost(struct svc_xpt_user *u)
629{
630 struct nfsd4_conn *c = container_of(u, struct nfsd4_conn, cn_xpt_user);
631 struct nfs4_client *clp = c->cn_session->se_client;
632
633 spin_lock(&clp->cl_lock);
634 if (!list_empty(&c->cn_persession)) {
635 list_del(&c->cn_persession);
636 free_conn(c);
637 }
638 spin_unlock(&clp->cl_lock);
J. Bruce Fieldseea49802010-11-18 08:34:12 -0500639 nfsd4_probe_callback(clp);
J. Bruce Fields19cf5c02010-06-06 18:37:16 -0400640}
641
J. Bruce Fieldsd29c3742010-06-15 17:34:11 -0400642static struct nfsd4_conn *alloc_conn(struct svc_rqst *rqstp, u32 flags)
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400643{
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400644 struct nfsd4_conn *conn;
645
646 conn = kmalloc(sizeof(struct nfsd4_conn), GFP_KERNEL);
647 if (!conn)
J. Bruce Fieldsdb906812010-09-29 15:29:32 -0400648 return NULL;
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400649 svc_xprt_get(rqstp->rq_xprt);
650 conn->cn_xprt = rqstp->rq_xprt;
J. Bruce Fieldsd29c3742010-06-15 17:34:11 -0400651 conn->cn_flags = flags;
J. Bruce Fieldsdb906812010-09-29 15:29:32 -0400652 INIT_LIST_HEAD(&conn->cn_xpt_user.list);
653 return conn;
654}
655
J. Bruce Fields328ead22010-09-29 16:11:06 -0400656static void __nfsd4_hash_conn(struct nfsd4_conn *conn, struct nfsd4_session *ses)
657{
658 conn->cn_session = ses;
659 list_add(&conn->cn_persession, &ses->se_conns);
660}
661
J. Bruce Fieldsdb906812010-09-29 15:29:32 -0400662static void nfsd4_hash_conn(struct nfsd4_conn *conn, struct nfsd4_session *ses)
663{
664 struct nfs4_client *clp = ses->se_client;
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400665
666 spin_lock(&clp->cl_lock);
J. Bruce Fields328ead22010-09-29 16:11:06 -0400667 __nfsd4_hash_conn(conn, ses);
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400668 spin_unlock(&clp->cl_lock);
J. Bruce Fieldsdb906812010-09-29 15:29:32 -0400669}
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400670
J. Bruce Fields21b75b02010-10-26 10:07:17 -0400671static int nfsd4_register_conn(struct nfsd4_conn *conn)
J. Bruce Fieldsdb906812010-09-29 15:29:32 -0400672{
J. Bruce Fields19cf5c02010-06-06 18:37:16 -0400673 conn->cn_xpt_user.callback = nfsd4_conn_lost;
J. Bruce Fields21b75b02010-10-26 10:07:17 -0400674 return register_xpt_user(conn->cn_xprt, &conn->cn_xpt_user);
J. Bruce Fieldsdb906812010-09-29 15:29:32 -0400675}
676
J. Bruce Fields1d1bc8f2010-10-04 23:12:59 -0400677static __be32 nfsd4_new_conn(struct svc_rqst *rqstp, struct nfsd4_session *ses, u32 dir)
J. Bruce Fieldsdb906812010-09-29 15:29:32 -0400678{
679 struct nfsd4_conn *conn;
J. Bruce Fields21b75b02010-10-26 10:07:17 -0400680 int ret;
J. Bruce Fieldsdb906812010-09-29 15:29:32 -0400681
J. Bruce Fields1d1bc8f2010-10-04 23:12:59 -0400682 conn = alloc_conn(rqstp, dir);
J. Bruce Fieldsdb906812010-09-29 15:29:32 -0400683 if (!conn)
684 return nfserr_jukebox;
685 nfsd4_hash_conn(conn, ses);
J. Bruce Fields21b75b02010-10-26 10:07:17 -0400686 ret = nfsd4_register_conn(conn);
687 if (ret)
688 /* oops; xprt is already down: */
689 nfsd4_conn_lost(&conn->cn_xpt_user);
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400690 return nfs_ok;
691}
692
J. Bruce Fields1d1bc8f2010-10-04 23:12:59 -0400693static __be32 nfsd4_new_conn_from_crses(struct svc_rqst *rqstp, struct nfsd4_session *ses)
694{
695 u32 dir = NFS4_CDFC4_FORE;
696
697 if (ses->se_flags & SESSION4_BACK_CHAN)
698 dir |= NFS4_CDFC4_BACK;
699
700 return nfsd4_new_conn(rqstp, ses, dir);
701}
702
703/* must be called under client_lock */
J. Bruce Fields19cf5c02010-06-06 18:37:16 -0400704static void nfsd4_del_conns(struct nfsd4_session *s)
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400705{
J. Bruce Fields19cf5c02010-06-06 18:37:16 -0400706 struct nfs4_client *clp = s->se_client;
707 struct nfsd4_conn *c;
708
709 spin_lock(&clp->cl_lock);
710 while (!list_empty(&s->se_conns)) {
711 c = list_first_entry(&s->se_conns, struct nfsd4_conn, cn_persession);
712 list_del_init(&c->cn_persession);
713 spin_unlock(&clp->cl_lock);
714
715 unregister_xpt_user(c->cn_xprt, &c->cn_xpt_user);
716 free_conn(c);
717
718 spin_lock(&clp->cl_lock);
719 }
720 spin_unlock(&clp->cl_lock);
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400721}
722
723void free_session(struct kref *kref)
724{
725 struct nfsd4_session *ses;
726 int mem;
727
728 ses = container_of(kref, struct nfsd4_session, se_ref);
J. Bruce Fields19cf5c02010-06-06 18:37:16 -0400729 nfsd4_del_conns(ses);
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400730 spin_lock(&nfsd_drc_lock);
731 mem = ses->se_fchannel.maxreqs * slot_bytes(&ses->se_fchannel);
732 nfsd_drc_mem_used -= mem;
733 spin_unlock(&nfsd_drc_lock);
734 free_session_slots(ses);
735 kfree(ses);
736}
737
J. Bruce Fieldsac7c46f2010-06-14 19:01:57 -0400738static 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 -0400739{
740 struct nfsd4_session *new;
741 struct nfsd4_channel_attrs *fchan = &cses->fore_channel;
742 int numslots, slotsize;
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400743 int status;
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400744 int idx;
745
746 /*
747 * Note decreasing slot size below client's request may
748 * make it difficult for client to function correctly, whereas
749 * decreasing the number of slots will (just?) affect
750 * performance. When short on memory we therefore prefer to
751 * decrease number of slots instead of their size.
752 */
753 slotsize = nfsd4_sanitize_slot_size(fchan->maxresp_cached);
754 numslots = nfsd4_get_drc_mem(slotsize, fchan->maxreqs);
Mi Jinlongced6dfe2010-11-11 18:03:50 +0800755 if (numslots < 1)
756 return NULL;
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400757
758 new = alloc_session(slotsize, numslots);
759 if (!new) {
760 nfsd4_put_drc_mem(slotsize, fchan->maxreqs);
J. Bruce Fieldsac7c46f2010-06-14 19:01:57 -0400761 return NULL;
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400762 }
763 init_forechannel_attrs(&new->se_fchannel, fchan, numslots, slotsize);
Andy Adamson557ce262009-08-28 08:45:04 -0400764
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300765 new->se_client = clp;
766 gen_sessionid(new);
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300767
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400768 INIT_LIST_HEAD(&new->se_conns);
769
J. Bruce Fieldsac7c46f2010-06-14 19:01:57 -0400770 new->se_cb_seq_nr = 1;
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300771 new->se_flags = cses->flags;
J. Bruce Fields8b5ce5c2010-10-19 17:31:50 -0400772 new->se_cb_prog = cses->callback_prog;
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300773 kref_init(&new->se_ref);
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400774 idx = hash_sessionid(&new->se_sessionid);
Benny Halevy9089f1b2010-05-12 00:12:26 +0300775 spin_lock(&client_lock);
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300776 list_add(&new->se_hash, &sessionid_hashtbl[idx]);
J. Bruce Fields4c649372010-06-15 14:22:37 -0400777 spin_lock(&clp->cl_lock);
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300778 list_add(&new->se_perclnt, &clp->cl_sessions);
J. Bruce Fields4c649372010-06-15 14:22:37 -0400779 spin_unlock(&clp->cl_lock);
Benny Halevy9089f1b2010-05-12 00:12:26 +0300780 spin_unlock(&client_lock);
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300781
J. Bruce Fields1d1bc8f2010-10-04 23:12:59 -0400782 status = nfsd4_new_conn_from_crses(rqstp, new);
J. Bruce Fieldsac7c46f2010-06-14 19:01:57 -0400783 /* whoops: benny points out, status is ignored! (err, or bogus) */
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400784 if (status) {
785 free_session(&new->se_ref);
J. Bruce Fieldsac7c46f2010-06-14 19:01:57 -0400786 return NULL;
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400787 }
J. Bruce Fieldsdcbeaa62010-06-15 17:25:45 -0400788 if (cses->flags & SESSION4_BACK_CHAN) {
J. Bruce Fieldsedd76782010-06-14 22:26:31 -0400789 struct sockaddr *sa = svc_addr(rqstp);
J. Bruce Fieldsdcbeaa62010-06-15 17:25:45 -0400790 /*
791 * This is a little silly; with sessions there's no real
792 * use for the callback address. Use the peer address
793 * as a reasonable default for now, but consider fixing
794 * the rpc client not to require an address in the
795 * future:
796 */
J. Bruce Fieldsedd76782010-06-14 22:26:31 -0400797 rpc_copy_addr((struct sockaddr *)&clp->cl_cb_conn.cb_addr, sa);
798 clp->cl_cb_conn.cb_addrlen = svc_addr_len(sa);
J. Bruce Fieldsedd76782010-06-14 22:26:31 -0400799 }
J. Bruce Fieldsdcbeaa62010-06-15 17:25:45 -0400800 nfsd4_probe_callback(clp);
J. Bruce Fieldsac7c46f2010-06-14 19:01:57 -0400801 return new;
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300802}
803
Benny Halevy9089f1b2010-05-12 00:12:26 +0300804/* caller must hold client_lock */
Marc Eshel5282fd72009-04-03 08:27:52 +0300805static struct nfsd4_session *
806find_in_sessionid_hashtbl(struct nfs4_sessionid *sessionid)
807{
808 struct nfsd4_session *elem;
809 int idx;
810
811 dump_sessionid(__func__, sessionid);
812 idx = hash_sessionid(sessionid);
Marc Eshel5282fd72009-04-03 08:27:52 +0300813 /* Search in the appropriate list */
814 list_for_each_entry(elem, &sessionid_hashtbl[idx], se_hash) {
Marc Eshel5282fd72009-04-03 08:27:52 +0300815 if (!memcmp(elem->se_sessionid.data, sessionid->data,
816 NFS4_MAX_SESSIONID_LEN)) {
817 return elem;
818 }
819 }
820
821 dprintk("%s: session not found\n", __func__);
822 return NULL;
823}
824
Benny Halevy9089f1b2010-05-12 00:12:26 +0300825/* caller must hold client_lock */
Andy Adamson7116ed62009-04-03 08:27:43 +0300826static void
Marc Eshel5282fd72009-04-03 08:27:52 +0300827unhash_session(struct nfsd4_session *ses)
Andy Adamson7116ed62009-04-03 08:27:43 +0300828{
829 list_del(&ses->se_hash);
J. Bruce Fields4c649372010-06-15 14:22:37 -0400830 spin_lock(&ses->se_client->cl_lock);
Andy Adamson7116ed62009-04-03 08:27:43 +0300831 list_del(&ses->se_perclnt);
J. Bruce Fields4c649372010-06-15 14:22:37 -0400832 spin_unlock(&ses->se_client->cl_lock);
Marc Eshel5282fd72009-04-03 08:27:52 +0300833}
834
Benny Halevy36acb662010-05-12 00:13:04 +0300835/* must be called under the client_lock */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700836static inline void
Benny Halevy36acb662010-05-12 00:13:04 +0300837renew_client_locked(struct nfs4_client *clp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700838{
Benny Halevy07cd4902010-05-12 00:13:41 +0300839 if (is_client_expired(clp)) {
840 dprintk("%s: client (clientid %08x/%08x) already expired\n",
841 __func__,
842 clp->cl_clientid.cl_boot,
843 clp->cl_clientid.cl_id);
844 return;
845 }
846
Linus Torvalds1da177e2005-04-16 15:20:36 -0700847 /*
848 * Move client to the end to the LRU list.
849 */
850 dprintk("renewing client (clientid %08x/%08x)\n",
851 clp->cl_clientid.cl_boot,
852 clp->cl_clientid.cl_id);
853 list_move_tail(&clp->cl_lru, &client_lru);
854 clp->cl_time = get_seconds();
855}
856
Benny Halevy36acb662010-05-12 00:13:04 +0300857static inline void
858renew_client(struct nfs4_client *clp)
859{
860 spin_lock(&client_lock);
861 renew_client_locked(clp);
862 spin_unlock(&client_lock);
863}
864
Linus Torvalds1da177e2005-04-16 15:20:36 -0700865/* SETCLIENTID and SETCLIENTID_CONFIRM Helper functions */
866static int
867STALE_CLIENTID(clientid_t *clid)
868{
869 if (clid->cl_boot == boot_time)
870 return 0;
Andy Adamson60adfc52009-04-03 08:28:50 +0300871 dprintk("NFSD stale clientid (%08x/%08x) boot_time %08lx\n",
872 clid->cl_boot, clid->cl_id, boot_time);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700873 return 1;
874}
875
876/*
877 * XXX Should we use a slab cache ?
878 * This type of memory management is somewhat inefficient, but we use it
879 * anyway since SETCLIENTID is not a common operation.
880 */
J. Bruce Fields35bba9a2007-11-21 22:07:08 -0500881static struct nfs4_client *alloc_client(struct xdr_netobj name)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700882{
883 struct nfs4_client *clp;
884
J. Bruce Fields35bba9a2007-11-21 22:07:08 -0500885 clp = kzalloc(sizeof(struct nfs4_client), GFP_KERNEL);
886 if (clp == NULL)
887 return NULL;
888 clp->cl_name.data = kmalloc(name.len, GFP_KERNEL);
889 if (clp->cl_name.data == NULL) {
890 kfree(clp);
891 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700892 }
J. Bruce Fields35bba9a2007-11-21 22:07:08 -0500893 memcpy(clp->cl_name.data, name.data, name.len);
894 clp->cl_name.len = name.len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700895 return clp;
896}
897
898static inline void
899free_client(struct nfs4_client *clp)
900{
J. Bruce Fields792c95d2010-10-12 19:55:25 -0400901 while (!list_empty(&clp->cl_sessions)) {
902 struct nfsd4_session *ses;
903 ses = list_entry(clp->cl_sessions.next, struct nfsd4_session,
904 se_perclnt);
905 list_del(&ses->se_perclnt);
906 nfsd4_put_session(ses);
907 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700908 if (clp->cl_cred.cr_group_info)
909 put_group_info(clp->cl_cred.cr_group_info);
Olga Kornievskaia68e76ad2008-12-23 16:17:15 -0500910 kfree(clp->cl_principal);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700911 kfree(clp->cl_name.data);
912 kfree(clp);
913}
914
Benny Halevyd7682982010-05-12 00:13:54 +0300915void
916release_session_client(struct nfsd4_session *session)
917{
918 struct nfs4_client *clp = session->se_client;
919
920 if (!atomic_dec_and_lock(&clp->cl_refcount, &client_lock))
921 return;
922 if (is_client_expired(clp)) {
923 free_client(clp);
924 session->se_client = NULL;
925 } else
926 renew_client_locked(clp);
927 spin_unlock(&client_lock);
Benny Halevyd7682982010-05-12 00:13:54 +0300928}
929
Benny Halevy84d38ac2010-05-12 00:13:16 +0300930/* must be called under the client_lock */
931static inline void
932unhash_client_locked(struct nfs4_client *clp)
933{
J. Bruce Fields792c95d2010-10-12 19:55:25 -0400934 struct nfsd4_session *ses;
935
Benny Halevy07cd4902010-05-12 00:13:41 +0300936 mark_client_expired(clp);
Benny Halevy84d38ac2010-05-12 00:13:16 +0300937 list_del(&clp->cl_lru);
J. Bruce Fields4c649372010-06-15 14:22:37 -0400938 spin_lock(&clp->cl_lock);
J. Bruce Fields792c95d2010-10-12 19:55:25 -0400939 list_for_each_entry(ses, &clp->cl_sessions, se_perclnt)
940 list_del_init(&ses->se_hash);
J. Bruce Fields4c649372010-06-15 14:22:37 -0400941 spin_unlock(&clp->cl_lock);
Benny Halevy84d38ac2010-05-12 00:13:16 +0300942}
943
Linus Torvalds1da177e2005-04-16 15:20:36 -0700944static void
945expire_client(struct nfs4_client *clp)
946{
947 struct nfs4_stateowner *sop;
948 struct nfs4_delegation *dp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700949 struct list_head reaplist;
950
Linus Torvalds1da177e2005-04-16 15:20:36 -0700951 INIT_LIST_HEAD(&reaplist);
952 spin_lock(&recall_lock);
NeilBrownea1da632005-06-23 22:04:17 -0700953 while (!list_empty(&clp->cl_delegations)) {
954 dp = list_entry(clp->cl_delegations.next, struct nfs4_delegation, dl_perclnt);
NeilBrownea1da632005-06-23 22:04:17 -0700955 list_del_init(&dp->dl_perclnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700956 list_move(&dp->dl_recall_lru, &reaplist);
957 }
958 spin_unlock(&recall_lock);
959 while (!list_empty(&reaplist)) {
960 dp = list_entry(reaplist.next, struct nfs4_delegation, dl_recall_lru);
961 list_del_init(&dp->dl_recall_lru);
962 unhash_delegation(dp);
963 }
NeilBrownea1da632005-06-23 22:04:17 -0700964 while (!list_empty(&clp->cl_openowners)) {
965 sop = list_entry(clp->cl_openowners.next, struct nfs4_stateowner, so_perclient);
J. Bruce Fieldsf044ff82009-01-11 15:24:04 -0500966 release_openowner(sop);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700967 }
J. Bruce Fields6ff8da02010-06-04 20:04:45 -0400968 nfsd4_shutdown_callback(clp);
J. Bruce Fields2bf23872010-03-08 12:37:27 -0500969 if (clp->cl_cb_conn.cb_xprt)
970 svc_xprt_put(clp->cl_cb_conn.cb_xprt);
Benny Halevy84d38ac2010-05-12 00:13:16 +0300971 list_del(&clp->cl_idhash);
972 list_del(&clp->cl_strhash);
973 spin_lock(&client_lock);
974 unhash_client_locked(clp);
Benny Halevy46583e22010-05-12 00:13:29 +0300975 if (atomic_read(&clp->cl_refcount) == 0)
976 free_client(clp);
Benny Halevy84d38ac2010-05-12 00:13:16 +0300977 spin_unlock(&client_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700978}
979
J. Bruce Fields35bba9a2007-11-21 22:07:08 -0500980static void copy_verf(struct nfs4_client *target, nfs4_verifier *source)
981{
982 memcpy(target->cl_verifier.data, source->data,
983 sizeof(target->cl_verifier.data));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700984}
985
J. Bruce Fields35bba9a2007-11-21 22:07:08 -0500986static void copy_clid(struct nfs4_client *target, struct nfs4_client *source)
987{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700988 target->cl_clientid.cl_boot = source->cl_clientid.cl_boot;
989 target->cl_clientid.cl_id = source->cl_clientid.cl_id;
990}
991
J. Bruce Fields35bba9a2007-11-21 22:07:08 -0500992static void copy_cred(struct svc_cred *target, struct svc_cred *source)
993{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700994 target->cr_uid = source->cr_uid;
995 target->cr_gid = source->cr_gid;
996 target->cr_group_info = source->cr_group_info;
997 get_group_info(target->cr_group_info);
998}
999
J. Bruce Fields35bba9a2007-11-21 22:07:08 -05001000static int same_name(const char *n1, const char *n2)
J. Bruce Fields599e0a22007-07-26 17:04:54 -04001001{
NeilBrowna55370a2005-06-23 22:03:52 -07001002 return 0 == memcmp(n1, n2, HEXDIR_LEN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001003}
1004
1005static int
J. Bruce Fields599e0a22007-07-26 17:04:54 -04001006same_verf(nfs4_verifier *v1, nfs4_verifier *v2)
1007{
1008 return 0 == memcmp(v1->data, v2->data, sizeof(v1->data));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001009}
1010
1011static int
J. Bruce Fields599e0a22007-07-26 17:04:54 -04001012same_clid(clientid_t *cl1, clientid_t *cl2)
1013{
1014 return (cl1->cl_boot == cl2->cl_boot) && (cl1->cl_id == cl2->cl_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001015}
1016
1017/* XXX what about NGROUP */
1018static int
J. Bruce Fields599e0a22007-07-26 17:04:54 -04001019same_creds(struct svc_cred *cr1, struct svc_cred *cr2)
1020{
1021 return cr1->cr_uid == cr2->cr_uid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001022}
1023
J. Bruce Fields5ec7b462007-11-21 21:58:56 -05001024static void gen_clid(struct nfs4_client *clp)
1025{
1026 static u32 current_clientid = 1;
1027
Linus Torvalds1da177e2005-04-16 15:20:36 -07001028 clp->cl_clientid.cl_boot = boot_time;
1029 clp->cl_clientid.cl_id = current_clientid++;
1030}
1031
J. Bruce Fieldsdeda2fa2007-11-19 20:31:04 -05001032static void gen_confirm(struct nfs4_client *clp)
1033{
1034 static u32 i;
1035 u32 *p;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001036
Linus Torvalds1da177e2005-04-16 15:20:36 -07001037 p = (u32 *)clp->cl_confirm.data;
J. Bruce Fieldsdeda2fa2007-11-19 20:31:04 -05001038 *p++ = get_seconds();
1039 *p++ = i++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001040}
1041
Ricardo Labiagab09333c2009-09-10 12:27:34 +03001042static struct nfs4_client *create_client(struct xdr_netobj name, char *recdir,
1043 struct svc_rqst *rqstp, nfs4_verifier *verf)
1044{
1045 struct nfs4_client *clp;
1046 struct sockaddr *sa = svc_addr(rqstp);
1047 char *princ;
1048
1049 clp = alloc_client(name);
1050 if (clp == NULL)
1051 return NULL;
1052
J. Bruce Fields792c95d2010-10-12 19:55:25 -04001053 INIT_LIST_HEAD(&clp->cl_sessions);
1054
Ricardo Labiagab09333c2009-09-10 12:27:34 +03001055 princ = svc_gss_principal(rqstp);
1056 if (princ) {
1057 clp->cl_principal = kstrdup(princ, GFP_KERNEL);
1058 if (clp->cl_principal == NULL) {
1059 free_client(clp);
1060 return NULL;
1061 }
1062 }
1063
1064 memcpy(clp->cl_recdir, recdir, HEXDIR_LEN);
Benny Halevy46583e22010-05-12 00:13:29 +03001065 atomic_set(&clp->cl_refcount, 0);
J. Bruce Fields77a35692010-04-30 18:51:44 -04001066 clp->cl_cb_state = NFSD4_CB_UNKNOWN;
Ricardo Labiagab09333c2009-09-10 12:27:34 +03001067 INIT_LIST_HEAD(&clp->cl_idhash);
1068 INIT_LIST_HEAD(&clp->cl_strhash);
1069 INIT_LIST_HEAD(&clp->cl_openowners);
1070 INIT_LIST_HEAD(&clp->cl_delegations);
Ricardo Labiagab09333c2009-09-10 12:27:34 +03001071 INIT_LIST_HEAD(&clp->cl_lru);
J. Bruce Fields5ce8ba22011-01-10 16:44:41 -05001072 INIT_LIST_HEAD(&clp->cl_callbacks);
J. Bruce Fields6ff8da02010-06-04 20:04:45 -04001073 spin_lock_init(&clp->cl_lock);
J. Bruce Fieldscee277d2010-05-26 17:52:14 -04001074 INIT_WORK(&clp->cl_cb_null.cb_work, nfsd4_do_callback_rpc);
Benny Halevy07cd4902010-05-12 00:13:41 +03001075 clp->cl_time = get_seconds();
Ricardo Labiagab09333c2009-09-10 12:27:34 +03001076 clear_bit(0, &clp->cl_cb_slot_busy);
1077 rpc_init_wait_queue(&clp->cl_cb_waitq, "Backchannel slot table");
1078 copy_verf(clp, verf);
1079 rpc_copy_addr((struct sockaddr *) &clp->cl_addr, sa);
1080 clp->cl_flavor = rqstp->rq_flavor;
1081 copy_cred(&clp->cl_cred, &rqstp->rq_cred);
1082 gen_confirm(clp);
J. Bruce Fieldsedd76782010-06-14 22:26:31 -04001083 clp->cl_cb_session = NULL;
Ricardo Labiagab09333c2009-09-10 12:27:34 +03001084 return clp;
1085}
1086
J. Bruce Fields35bba9a2007-11-21 22:07:08 -05001087static int check_name(struct xdr_netobj name)
1088{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001089 if (name.len == 0)
1090 return 0;
1091 if (name.len > NFS4_OPAQUE_LIMIT) {
J. Bruce Fields2fdada02007-07-27 16:10:37 -04001092 dprintk("NFSD: check_name: name too long(%d)!\n", name.len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001093 return 0;
1094 }
1095 return 1;
1096}
1097
NeilBrownfd39ca92005-06-23 22:04:03 -07001098static void
Linus Torvalds1da177e2005-04-16 15:20:36 -07001099add_to_unconfirmed(struct nfs4_client *clp, unsigned int strhashval)
1100{
1101 unsigned int idhashval;
1102
1103 list_add(&clp->cl_strhash, &unconf_str_hashtbl[strhashval]);
1104 idhashval = clientid_hashval(clp->cl_clientid.cl_id);
1105 list_add(&clp->cl_idhash, &unconf_id_hashtbl[idhashval]);
Benny Halevy36acb662010-05-12 00:13:04 +03001106 renew_client(clp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001107}
1108
NeilBrownfd39ca92005-06-23 22:04:03 -07001109static void
Linus Torvalds1da177e2005-04-16 15:20:36 -07001110move_to_confirmed(struct nfs4_client *clp)
1111{
1112 unsigned int idhashval = clientid_hashval(clp->cl_clientid.cl_id);
1113 unsigned int strhashval;
1114
1115 dprintk("NFSD: move_to_confirm nfs4_client %p\n", clp);
Akinobu Mitaf1166292006-06-26 00:24:46 -07001116 list_move(&clp->cl_idhash, &conf_id_hashtbl[idhashval]);
NeilBrowna55370a2005-06-23 22:03:52 -07001117 strhashval = clientstr_hashval(clp->cl_recdir);
Benny Halevy328efba2010-05-12 00:12:51 +03001118 list_move(&clp->cl_strhash, &conf_str_hashtbl[strhashval]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001119 renew_client(clp);
1120}
1121
1122static struct nfs4_client *
1123find_confirmed_client(clientid_t *clid)
1124{
1125 struct nfs4_client *clp;
1126 unsigned int idhashval = clientid_hashval(clid->cl_id);
1127
1128 list_for_each_entry(clp, &conf_id_hashtbl[idhashval], cl_idhash) {
J. Bruce Fields599e0a22007-07-26 17:04:54 -04001129 if (same_clid(&clp->cl_clientid, clid))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001130 return clp;
1131 }
1132 return NULL;
1133}
1134
1135static struct nfs4_client *
1136find_unconfirmed_client(clientid_t *clid)
1137{
1138 struct nfs4_client *clp;
1139 unsigned int idhashval = clientid_hashval(clid->cl_id);
1140
1141 list_for_each_entry(clp, &unconf_id_hashtbl[idhashval], cl_idhash) {
J. Bruce Fields599e0a22007-07-26 17:04:54 -04001142 if (same_clid(&clp->cl_clientid, clid))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001143 return clp;
1144 }
1145 return NULL;
1146}
1147
J. Bruce Fields6e5f15c2010-11-24 17:17:34 -05001148static bool clp_used_exchangeid(struct nfs4_client *clp)
Andy Adamsona1bcecd2009-04-03 08:28:05 +03001149{
J. Bruce Fields6e5f15c2010-11-24 17:17:34 -05001150 return clp->cl_exchange_flags != 0;
J. Bruce Fieldse203d502010-11-24 17:30:54 -05001151}
Andy Adamsona1bcecd2009-04-03 08:28:05 +03001152
NeilBrown28ce6052005-06-23 22:03:56 -07001153static struct nfs4_client *
J. Bruce Fieldse203d502010-11-24 17:30:54 -05001154find_confirmed_client_by_str(const char *dname, unsigned int hashval)
NeilBrown28ce6052005-06-23 22:03:56 -07001155{
1156 struct nfs4_client *clp;
1157
1158 list_for_each_entry(clp, &conf_str_hashtbl[hashval], cl_strhash) {
J. Bruce Fieldse203d502010-11-24 17:30:54 -05001159 if (same_name(clp->cl_recdir, dname))
NeilBrown28ce6052005-06-23 22:03:56 -07001160 return clp;
1161 }
1162 return NULL;
1163}
1164
1165static struct nfs4_client *
J. Bruce Fieldse203d502010-11-24 17:30:54 -05001166find_unconfirmed_client_by_str(const char *dname, unsigned int hashval)
NeilBrown28ce6052005-06-23 22:03:56 -07001167{
1168 struct nfs4_client *clp;
1169
1170 list_for_each_entry(clp, &unconf_str_hashtbl[hashval], cl_strhash) {
J. Bruce Fieldse203d502010-11-24 17:30:54 -05001171 if (same_name(clp->cl_recdir, dname))
NeilBrown28ce6052005-06-23 22:03:56 -07001172 return clp;
1173 }
1174 return NULL;
1175}
1176
Takuma Umeya6f3d7722010-12-15 14:09:01 +09001177static void rpc_svcaddr2sockaddr(struct sockaddr *sa, unsigned short family, union svc_addr_u *svcaddr)
1178{
1179 switch (family) {
1180 case AF_INET:
1181 ((struct sockaddr_in *)sa)->sin_family = AF_INET;
1182 ((struct sockaddr_in *)sa)->sin_addr = svcaddr->addr;
1183 return;
1184 case AF_INET6:
1185 ((struct sockaddr_in6 *)sa)->sin6_family = AF_INET6;
1186 ((struct sockaddr_in6 *)sa)->sin6_addr = svcaddr->addr6;
1187 return;
1188 }
1189}
1190
NeilBrownfd39ca92005-06-23 22:04:03 -07001191static void
Takuma Umeya6f3d7722010-12-15 14:09:01 +09001192gen_callback(struct nfs4_client *clp, struct nfsd4_setclientid *se, struct svc_rqst *rqstp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001193{
J. Bruce Fields07263f12010-05-31 19:09:40 -04001194 struct nfs4_cb_conn *conn = &clp->cl_cb_conn;
Takuma Umeya6f3d7722010-12-15 14:09:01 +09001195 struct sockaddr *sa = svc_addr(rqstp);
1196 u32 scopeid = rpc_get_scope_id(sa);
Jeff Layton7077ecb2009-08-14 12:57:58 -04001197 unsigned short expected_family;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001198
Jeff Layton7077ecb2009-08-14 12:57:58 -04001199 /* Currently, we only support tcp and tcp6 for the callback channel */
1200 if (se->se_callback_netid_len == 3 &&
1201 !memcmp(se->se_callback_netid_val, "tcp", 3))
1202 expected_family = AF_INET;
1203 else if (se->se_callback_netid_len == 4 &&
1204 !memcmp(se->se_callback_netid_val, "tcp6", 4))
1205 expected_family = AF_INET6;
1206 else
Linus Torvalds1da177e2005-04-16 15:20:36 -07001207 goto out_err;
1208
J. Bruce Fields07263f12010-05-31 19:09:40 -04001209 conn->cb_addrlen = rpc_uaddr2sockaddr(se->se_callback_addr_val,
Jeff Laytonaa9a4ec2009-08-14 12:57:57 -04001210 se->se_callback_addr_len,
J. Bruce Fields07263f12010-05-31 19:09:40 -04001211 (struct sockaddr *)&conn->cb_addr,
1212 sizeof(conn->cb_addr));
Jeff Laytonaa9a4ec2009-08-14 12:57:57 -04001213
J. Bruce Fields07263f12010-05-31 19:09:40 -04001214 if (!conn->cb_addrlen || conn->cb_addr.ss_family != expected_family)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001215 goto out_err;
Jeff Laytonaa9a4ec2009-08-14 12:57:57 -04001216
J. Bruce Fields07263f12010-05-31 19:09:40 -04001217 if (conn->cb_addr.ss_family == AF_INET6)
1218 ((struct sockaddr_in6 *)&conn->cb_addr)->sin6_scope_id = scopeid;
Jeff Laytonfbf46652009-08-14 12:57:59 -04001219
J. Bruce Fields07263f12010-05-31 19:09:40 -04001220 conn->cb_prog = se->se_callback_prog;
1221 conn->cb_ident = se->se_callback_ident;
Takuma Umeya6f3d7722010-12-15 14:09:01 +09001222 rpc_svcaddr2sockaddr((struct sockaddr *)&conn->cb_saddr, expected_family, &rqstp->rq_daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001223 return;
1224out_err:
J. Bruce Fields07263f12010-05-31 19:09:40 -04001225 conn->cb_addr.ss_family = AF_UNSPEC;
1226 conn->cb_addrlen = 0;
Neil Brown849823c2005-09-13 01:25:36 -07001227 dprintk(KERN_INFO "NFSD: this client (clientid %08x/%08x) "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001228 "will not receive delegations\n",
1229 clp->cl_clientid.cl_boot, clp->cl_clientid.cl_id);
1230
Linus Torvalds1da177e2005-04-16 15:20:36 -07001231 return;
1232}
1233
Andy Adamson074fe892009-04-03 08:28:15 +03001234/*
Andy Adamson557ce262009-08-28 08:45:04 -04001235 * Cache a reply. nfsd4_check_drc_limit() has bounded the cache size.
Andy Adamson074fe892009-04-03 08:28:15 +03001236 */
1237void
1238nfsd4_store_cache_entry(struct nfsd4_compoundres *resp)
1239{
Andy Adamson557ce262009-08-28 08:45:04 -04001240 struct nfsd4_slot *slot = resp->cstate.slot;
1241 unsigned int base;
Andy Adamson074fe892009-04-03 08:28:15 +03001242
Andy Adamson557ce262009-08-28 08:45:04 -04001243 dprintk("--> %s slot %p\n", __func__, slot);
Andy Adamson074fe892009-04-03 08:28:15 +03001244
Andy Adamson557ce262009-08-28 08:45:04 -04001245 slot->sl_opcnt = resp->opcnt;
1246 slot->sl_status = resp->cstate.status;
Andy Adamsonbf864a32009-04-03 08:28:35 +03001247
1248 if (nfsd4_not_cached(resp)) {
Andy Adamson557ce262009-08-28 08:45:04 -04001249 slot->sl_datalen = 0;
Andy Adamsonbf864a32009-04-03 08:28:35 +03001250 return;
1251 }
Andy Adamson557ce262009-08-28 08:45:04 -04001252 slot->sl_datalen = (char *)resp->p - (char *)resp->cstate.datap;
1253 base = (char *)resp->cstate.datap -
1254 (char *)resp->xbuf->head[0].iov_base;
1255 if (read_bytes_from_xdr_buf(resp->xbuf, base, slot->sl_data,
1256 slot->sl_datalen))
1257 WARN("%s: sessions DRC could not cache compound\n", __func__);
1258 return;
Andy Adamson074fe892009-04-03 08:28:15 +03001259}
1260
1261/*
Andy Adamsonabfabf82009-07-23 19:02:18 -04001262 * Encode the replay sequence operation from the slot values.
1263 * If cachethis is FALSE encode the uncached rep error on the next
1264 * operation which sets resp->p and increments resp->opcnt for
1265 * nfs4svc_encode_compoundres.
1266 *
Andy Adamson074fe892009-04-03 08:28:15 +03001267 */
Andy Adamsonabfabf82009-07-23 19:02:18 -04001268static __be32
1269nfsd4_enc_sequence_replay(struct nfsd4_compoundargs *args,
1270 struct nfsd4_compoundres *resp)
Andy Adamson074fe892009-04-03 08:28:15 +03001271{
Andy Adamsonabfabf82009-07-23 19:02:18 -04001272 struct nfsd4_op *op;
1273 struct nfsd4_slot *slot = resp->cstate.slot;
Andy Adamson074fe892009-04-03 08:28:15 +03001274
Andy Adamsonabfabf82009-07-23 19:02:18 -04001275 dprintk("--> %s resp->opcnt %d cachethis %u \n", __func__,
Andy Adamson557ce262009-08-28 08:45:04 -04001276 resp->opcnt, resp->cstate.slot->sl_cachethis);
Andy Adamsonabfabf82009-07-23 19:02:18 -04001277
1278 /* Encode the replayed sequence operation */
1279 op = &args->ops[resp->opcnt - 1];
1280 nfsd4_encode_operation(resp, op);
1281
1282 /* Return nfserr_retry_uncached_rep in next operation. */
Andy Adamson557ce262009-08-28 08:45:04 -04001283 if (args->opcnt > 1 && slot->sl_cachethis == 0) {
Andy Adamsonabfabf82009-07-23 19:02:18 -04001284 op = &args->ops[resp->opcnt++];
1285 op->status = nfserr_retry_uncached_rep;
1286 nfsd4_encode_operation(resp, op);
Andy Adamson074fe892009-04-03 08:28:15 +03001287 }
Andy Adamsonabfabf82009-07-23 19:02:18 -04001288 return op->status;
Andy Adamson074fe892009-04-03 08:28:15 +03001289}
1290
1291/*
Andy Adamson557ce262009-08-28 08:45:04 -04001292 * The sequence operation is not cached because we can use the slot and
1293 * session values.
Andy Adamson074fe892009-04-03 08:28:15 +03001294 */
1295__be32
Andy Adamsonbf864a32009-04-03 08:28:35 +03001296nfsd4_replay_cache_entry(struct nfsd4_compoundres *resp,
1297 struct nfsd4_sequence *seq)
Andy Adamson074fe892009-04-03 08:28:15 +03001298{
Andy Adamson557ce262009-08-28 08:45:04 -04001299 struct nfsd4_slot *slot = resp->cstate.slot;
Andy Adamson074fe892009-04-03 08:28:15 +03001300 __be32 status;
1301
Andy Adamson557ce262009-08-28 08:45:04 -04001302 dprintk("--> %s slot %p\n", __func__, slot);
Andy Adamson074fe892009-04-03 08:28:15 +03001303
Andy Adamsonabfabf82009-07-23 19:02:18 -04001304 /* Either returns 0 or nfserr_retry_uncached */
1305 status = nfsd4_enc_sequence_replay(resp->rqstp->rq_argp, resp);
1306 if (status == nfserr_retry_uncached_rep)
1307 return status;
Andy Adamson074fe892009-04-03 08:28:15 +03001308
Andy Adamson557ce262009-08-28 08:45:04 -04001309 /* The sequence operation has been encoded, cstate->datap set. */
1310 memcpy(resp->cstate.datap, slot->sl_data, slot->sl_datalen);
Andy Adamson074fe892009-04-03 08:28:15 +03001311
Andy Adamson557ce262009-08-28 08:45:04 -04001312 resp->opcnt = slot->sl_opcnt;
1313 resp->p = resp->cstate.datap + XDR_QUADLEN(slot->sl_datalen);
1314 status = slot->sl_status;
Andy Adamson074fe892009-04-03 08:28:15 +03001315
1316 return status;
1317}
1318
Andy Adamson0733d212009-04-03 08:28:01 +03001319/*
1320 * Set the exchange_id flags returned by the server.
1321 */
1322static void
1323nfsd4_set_ex_flags(struct nfs4_client *new, struct nfsd4_exchange_id *clid)
1324{
1325 /* pNFS is not supported */
1326 new->cl_exchange_flags |= EXCHGID4_FLAG_USE_NON_PNFS;
1327
1328 /* Referrals are supported, Migration is not. */
1329 new->cl_exchange_flags |= EXCHGID4_FLAG_SUPP_MOVED_REFER;
1330
1331 /* set the wire flags to return to client. */
1332 clid->flags = new->cl_exchange_flags;
1333}
1334
Al Virob37ad282006-10-19 23:28:59 -07001335__be32
Andy Adamson069b6ad2009-04-03 08:27:58 +03001336nfsd4_exchange_id(struct svc_rqst *rqstp,
1337 struct nfsd4_compound_state *cstate,
1338 struct nfsd4_exchange_id *exid)
1339{
Andy Adamson0733d212009-04-03 08:28:01 +03001340 struct nfs4_client *unconf, *conf, *new;
1341 int status;
1342 unsigned int strhashval;
1343 char dname[HEXDIR_LEN];
Jeff Layton363168b2009-08-14 12:57:56 -04001344 char addr_str[INET6_ADDRSTRLEN];
Andy Adamson0733d212009-04-03 08:28:01 +03001345 nfs4_verifier verf = exid->verifier;
Jeff Layton363168b2009-08-14 12:57:56 -04001346 struct sockaddr *sa = svc_addr(rqstp);
Andy Adamson0733d212009-04-03 08:28:01 +03001347
Jeff Layton363168b2009-08-14 12:57:56 -04001348 rpc_ntop(sa, addr_str, sizeof(addr_str));
Andy Adamson0733d212009-04-03 08:28:01 +03001349 dprintk("%s rqstp=%p exid=%p clname.len=%u clname.data=%p "
Jeff Layton363168b2009-08-14 12:57:56 -04001350 "ip_addr=%s flags %x, spa_how %d\n",
Andy Adamson0733d212009-04-03 08:28:01 +03001351 __func__, rqstp, exid, exid->clname.len, exid->clname.data,
Jeff Layton363168b2009-08-14 12:57:56 -04001352 addr_str, exid->flags, exid->spa_how);
Andy Adamson0733d212009-04-03 08:28:01 +03001353
1354 if (!check_name(exid->clname) || (exid->flags & ~EXCHGID4_FLAG_MASK_A))
1355 return nfserr_inval;
1356
1357 /* Currently only support SP4_NONE */
1358 switch (exid->spa_how) {
1359 case SP4_NONE:
1360 break;
1361 case SP4_SSV:
J. Bruce Fields044bc1d2010-11-12 14:36:06 -05001362 return nfserr_serverfault;
Andy Adamson0733d212009-04-03 08:28:01 +03001363 default:
1364 BUG(); /* checked by xdr code */
1365 case SP4_MACH_CRED:
1366 return nfserr_serverfault; /* no excuse :-/ */
1367 }
1368
1369 status = nfs4_make_rec_clidname(dname, &exid->clname);
1370
1371 if (status)
1372 goto error;
1373
1374 strhashval = clientstr_hashval(dname);
1375
1376 nfs4_lock_state();
1377 status = nfs_ok;
1378
J. Bruce Fieldse203d502010-11-24 17:30:54 -05001379 conf = find_confirmed_client_by_str(dname, strhashval);
Andy Adamson0733d212009-04-03 08:28:01 +03001380 if (conf) {
J. Bruce Fieldse203d502010-11-24 17:30:54 -05001381 if (!clp_used_exchangeid(conf)) {
1382 status = nfserr_clid_inuse; /* XXX: ? */
1383 goto out;
1384 }
Andy Adamson0733d212009-04-03 08:28:01 +03001385 if (!same_verf(&verf, &conf->cl_verifier)) {
1386 /* 18.35.4 case 8 */
1387 if (exid->flags & EXCHGID4_FLAG_UPD_CONFIRMED_REC_A) {
1388 status = nfserr_not_same;
1389 goto out;
1390 }
1391 /* Client reboot: destroy old state */
1392 expire_client(conf);
1393 goto out_new;
1394 }
1395 if (!same_creds(&conf->cl_cred, &rqstp->rq_cred)) {
1396 /* 18.35.4 case 9 */
1397 if (exid->flags & EXCHGID4_FLAG_UPD_CONFIRMED_REC_A) {
1398 status = nfserr_perm;
1399 goto out;
1400 }
1401 expire_client(conf);
1402 goto out_new;
1403 }
Andy Adamson0733d212009-04-03 08:28:01 +03001404 /*
1405 * Set bit when the owner id and verifier map to an already
1406 * confirmed client id (18.35.3).
1407 */
1408 exid->flags |= EXCHGID4_FLAG_CONFIRMED_R;
1409
1410 /*
1411 * Falling into 18.35.4 case 2, possible router replay.
1412 * Leave confirmed record intact and return same result.
1413 */
1414 copy_verf(conf, &verf);
1415 new = conf;
1416 goto out_copy;
Mike Sager6ddbbbf2009-06-16 04:20:47 +03001417 }
1418
1419 /* 18.35.4 case 7 */
1420 if (exid->flags & EXCHGID4_FLAG_UPD_CONFIRMED_REC_A) {
1421 status = nfserr_noent;
1422 goto out;
Andy Adamson0733d212009-04-03 08:28:01 +03001423 }
1424
J. Bruce Fieldse203d502010-11-24 17:30:54 -05001425 unconf = find_unconfirmed_client_by_str(dname, strhashval);
Andy Adamson0733d212009-04-03 08:28:01 +03001426 if (unconf) {
1427 /*
1428 * Possible retry or client restart. Per 18.35.4 case 4,
1429 * a new unconfirmed record should be generated regardless
1430 * of whether any properties have changed.
1431 */
1432 expire_client(unconf);
1433 }
1434
1435out_new:
1436 /* Normal case */
Ricardo Labiagab09333c2009-09-10 12:27:34 +03001437 new = create_client(exid->clname, dname, rqstp, &verf);
Andy Adamson0733d212009-04-03 08:28:01 +03001438 if (new == NULL) {
J. Bruce Fields47310302010-06-22 16:17:12 -04001439 status = nfserr_jukebox;
Andy Adamson0733d212009-04-03 08:28:01 +03001440 goto out;
1441 }
1442
Andy Adamson0733d212009-04-03 08:28:01 +03001443 gen_clid(new);
Andy Adamson0733d212009-04-03 08:28:01 +03001444 add_to_unconfirmed(new, strhashval);
1445out_copy:
1446 exid->clientid.cl_boot = new->cl_clientid.cl_boot;
1447 exid->clientid.cl_id = new->cl_clientid.cl_id;
1448
Andy Adamson38eb76a2009-04-03 08:28:32 +03001449 exid->seqid = 1;
Andy Adamson0733d212009-04-03 08:28:01 +03001450 nfsd4_set_ex_flags(new, exid);
1451
1452 dprintk("nfsd4_exchange_id seqid %d flags %x\n",
Andy Adamson49557cc2009-07-23 19:02:16 -04001453 new->cl_cs_slot.sl_seqid, new->cl_exchange_flags);
Andy Adamson0733d212009-04-03 08:28:01 +03001454 status = nfs_ok;
1455
1456out:
1457 nfs4_unlock_state();
1458error:
1459 dprintk("nfsd4_exchange_id returns %d\n", ntohl(status));
1460 return status;
Andy Adamson069b6ad2009-04-03 08:27:58 +03001461}
1462
Benny Halevyb85d4c02009-04-03 08:28:08 +03001463static int
Andy Adamson88e588d2009-07-23 19:02:15 -04001464check_slot_seqid(u32 seqid, u32 slot_seqid, int slot_inuse)
Benny Halevyb85d4c02009-04-03 08:28:08 +03001465{
Andy Adamson88e588d2009-07-23 19:02:15 -04001466 dprintk("%s enter. seqid %d slot_seqid %d\n", __func__, seqid,
1467 slot_seqid);
Benny Halevyb85d4c02009-04-03 08:28:08 +03001468
1469 /* The slot is in use, and no response has been sent. */
Andy Adamson88e588d2009-07-23 19:02:15 -04001470 if (slot_inuse) {
1471 if (seqid == slot_seqid)
Benny Halevyb85d4c02009-04-03 08:28:08 +03001472 return nfserr_jukebox;
1473 else
1474 return nfserr_seq_misordered;
1475 }
1476 /* Normal */
Andy Adamson88e588d2009-07-23 19:02:15 -04001477 if (likely(seqid == slot_seqid + 1))
Benny Halevyb85d4c02009-04-03 08:28:08 +03001478 return nfs_ok;
1479 /* Replay */
Andy Adamson88e588d2009-07-23 19:02:15 -04001480 if (seqid == slot_seqid)
Benny Halevyb85d4c02009-04-03 08:28:08 +03001481 return nfserr_replay_cache;
1482 /* Wraparound */
Andy Adamson88e588d2009-07-23 19:02:15 -04001483 if (seqid == 1 && (slot_seqid + 1) == 0)
Benny Halevyb85d4c02009-04-03 08:28:08 +03001484 return nfs_ok;
1485 /* Misordered replay or misordered new request */
1486 return nfserr_seq_misordered;
1487}
1488
Andy Adamson49557cc2009-07-23 19:02:16 -04001489/*
1490 * Cache the create session result into the create session single DRC
1491 * slot cache by saving the xdr structure. sl_seqid has been set.
1492 * Do this for solo or embedded create session operations.
1493 */
1494static void
1495nfsd4_cache_create_session(struct nfsd4_create_session *cr_ses,
1496 struct nfsd4_clid_slot *slot, int nfserr)
1497{
1498 slot->sl_status = nfserr;
1499 memcpy(&slot->sl_cr_ses, cr_ses, sizeof(*cr_ses));
1500}
1501
1502static __be32
1503nfsd4_replay_create_session(struct nfsd4_create_session *cr_ses,
1504 struct nfsd4_clid_slot *slot)
1505{
1506 memcpy(cr_ses, &slot->sl_cr_ses, sizeof(*cr_ses));
1507 return slot->sl_status;
1508}
1509
Andy Adamson069b6ad2009-04-03 08:27:58 +03001510__be32
1511nfsd4_create_session(struct svc_rqst *rqstp,
1512 struct nfsd4_compound_state *cstate,
1513 struct nfsd4_create_session *cr_ses)
1514{
Jeff Layton363168b2009-08-14 12:57:56 -04001515 struct sockaddr *sa = svc_addr(rqstp);
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001516 struct nfs4_client *conf, *unconf;
J. Bruce Fieldsac7c46f2010-06-14 19:01:57 -04001517 struct nfsd4_session *new;
Andy Adamson49557cc2009-07-23 19:02:16 -04001518 struct nfsd4_clid_slot *cs_slot = NULL;
J. Bruce Fields86c3e162010-10-02 17:04:00 -04001519 bool confirm_me = false;
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001520 int status = 0;
1521
Mi Jinlonga62573d2011-03-23 17:57:07 +08001522 if (cr_ses->flags & ~SESSION4_FLAG_MASK_A)
1523 return nfserr_inval;
1524
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001525 nfs4_lock_state();
1526 unconf = find_unconfirmed_client(&cr_ses->clientid);
1527 conf = find_confirmed_client(&cr_ses->clientid);
1528
1529 if (conf) {
Andy Adamson49557cc2009-07-23 19:02:16 -04001530 cs_slot = &conf->cl_cs_slot;
1531 status = check_slot_seqid(cr_ses->seqid, cs_slot->sl_seqid, 0);
Andy Adamson38eb76a2009-04-03 08:28:32 +03001532 if (status == nfserr_replay_cache) {
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001533 dprintk("Got a create_session replay! seqid= %d\n",
Andy Adamson49557cc2009-07-23 19:02:16 -04001534 cs_slot->sl_seqid);
Andy Adamson38eb76a2009-04-03 08:28:32 +03001535 /* Return the cached reply status */
Andy Adamson49557cc2009-07-23 19:02:16 -04001536 status = nfsd4_replay_create_session(cr_ses, cs_slot);
Andy Adamson38eb76a2009-04-03 08:28:32 +03001537 goto out;
Andy Adamson49557cc2009-07-23 19:02:16 -04001538 } else if (cr_ses->seqid != cs_slot->sl_seqid + 1) {
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001539 status = nfserr_seq_misordered;
1540 dprintk("Sequence misordered!\n");
1541 dprintk("Expected seqid= %d but got seqid= %d\n",
Andy Adamson49557cc2009-07-23 19:02:16 -04001542 cs_slot->sl_seqid, cr_ses->seqid);
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001543 goto out;
1544 }
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001545 } else if (unconf) {
1546 if (!same_creds(&unconf->cl_cred, &rqstp->rq_cred) ||
Jeff Layton363168b2009-08-14 12:57:56 -04001547 !rpc_cmp_addr(sa, (struct sockaddr *) &unconf->cl_addr)) {
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001548 status = nfserr_clid_inuse;
1549 goto out;
1550 }
1551
Andy Adamson49557cc2009-07-23 19:02:16 -04001552 cs_slot = &unconf->cl_cs_slot;
1553 status = check_slot_seqid(cr_ses->seqid, cs_slot->sl_seqid, 0);
Andy Adamson38eb76a2009-04-03 08:28:32 +03001554 if (status) {
1555 /* an unconfirmed replay returns misordered */
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001556 status = nfserr_seq_misordered;
J. Bruce Fieldscd5b8142010-10-02 17:03:35 -04001557 goto out;
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001558 }
1559
J. Bruce Fields86c3e162010-10-02 17:04:00 -04001560 confirm_me = true;
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001561 conf = unconf;
1562 } else {
1563 status = nfserr_stale_clientid;
1564 goto out;
1565 }
1566
J. Bruce Fields408b79b2010-04-15 15:11:09 -04001567 /*
J. Bruce Fields8323c3b2010-10-19 19:36:51 -04001568 * XXX: we should probably set this at creation time, and check
1569 * for consistent minorversion use throughout:
1570 */
1571 conf->cl_minorversion = 1;
1572 /*
J. Bruce Fields408b79b2010-04-15 15:11:09 -04001573 * We do not support RDMA or persistent sessions
1574 */
1575 cr_ses->flags &= ~SESSION4_PERSIST;
1576 cr_ses->flags &= ~SESSION4_RDMA;
1577
J. Bruce Fieldsac7c46f2010-06-14 19:01:57 -04001578 status = nfserr_jukebox;
1579 new = alloc_init_session(rqstp, conf, cr_ses);
1580 if (!new)
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001581 goto out;
J. Bruce Fieldsac7c46f2010-06-14 19:01:57 -04001582 status = nfs_ok;
1583 memcpy(cr_ses->sessionid.data, new->se_sessionid.data,
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001584 NFS4_MAX_SESSIONID_LEN);
Mi Jinlong12050652010-11-11 18:03:40 +08001585 memcpy(&cr_ses->fore_channel, &new->se_fchannel,
1586 sizeof(struct nfsd4_channel_attrs));
J. Bruce Fields86c3e162010-10-02 17:04:00 -04001587 cs_slot->sl_seqid++;
Andy Adamson49557cc2009-07-23 19:02:16 -04001588 cr_ses->seqid = cs_slot->sl_seqid;
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001589
Andy Adamson49557cc2009-07-23 19:02:16 -04001590 /* cache solo and embedded create sessions under the state lock */
1591 nfsd4_cache_create_session(cr_ses, cs_slot, status);
J. Bruce Fields86c3e162010-10-02 17:04:00 -04001592 if (confirm_me)
1593 move_to_confirmed(conf);
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001594out:
1595 nfs4_unlock_state();
1596 dprintk("%s returns %d\n", __func__, ntohl(status));
1597 return status;
Andy Adamson069b6ad2009-04-03 08:27:58 +03001598}
1599
J. Bruce Fields57716352010-04-21 12:27:19 -04001600static bool nfsd4_last_compound_op(struct svc_rqst *rqstp)
1601{
1602 struct nfsd4_compoundres *resp = rqstp->rq_resp;
1603 struct nfsd4_compoundargs *argp = rqstp->rq_argp;
1604
1605 return argp->opcnt == resp->opcnt;
1606}
1607
J. Bruce Fields1d1bc8f2010-10-04 23:12:59 -04001608static __be32 nfsd4_map_bcts_dir(u32 *dir)
1609{
1610 switch (*dir) {
1611 case NFS4_CDFC4_FORE:
1612 case NFS4_CDFC4_BACK:
1613 return nfs_ok;
1614 case NFS4_CDFC4_FORE_OR_BOTH:
1615 case NFS4_CDFC4_BACK_OR_BOTH:
1616 *dir = NFS4_CDFC4_BOTH;
1617 return nfs_ok;
1618 };
1619 return nfserr_inval;
1620}
1621
1622__be32 nfsd4_bind_conn_to_session(struct svc_rqst *rqstp,
1623 struct nfsd4_compound_state *cstate,
1624 struct nfsd4_bind_conn_to_session *bcts)
1625{
1626 __be32 status;
1627
1628 if (!nfsd4_last_compound_op(rqstp))
1629 return nfserr_not_only_op;
1630 spin_lock(&client_lock);
1631 cstate->session = find_in_sessionid_hashtbl(&bcts->sessionid);
1632 /* Sorta weird: we only need the refcnt'ing because new_conn acquires
1633 * client_lock iself: */
1634 if (cstate->session) {
1635 nfsd4_get_session(cstate->session);
1636 atomic_inc(&cstate->session->se_client->cl_refcount);
1637 }
1638 spin_unlock(&client_lock);
1639 if (!cstate->session)
1640 return nfserr_badsession;
1641
1642 status = nfsd4_map_bcts_dir(&bcts->dir);
Bryan Schumaker1db2b9d2011-04-27 15:47:15 -04001643 if (!status)
1644 nfsd4_new_conn(rqstp, cstate->session, bcts->dir);
1645 return status;
J. Bruce Fields1d1bc8f2010-10-04 23:12:59 -04001646}
1647
J. Bruce Fields5d4cec22010-05-01 12:56:06 -04001648static bool nfsd4_compound_in_session(struct nfsd4_session *session, struct nfs4_sessionid *sid)
1649{
1650 if (!session)
1651 return 0;
1652 return !memcmp(sid, &session->se_sessionid, sizeof(*sid));
1653}
1654
Andy Adamson069b6ad2009-04-03 08:27:58 +03001655__be32
1656nfsd4_destroy_session(struct svc_rqst *r,
1657 struct nfsd4_compound_state *cstate,
1658 struct nfsd4_destroy_session *sessionid)
1659{
Benny Halevye10e0cf2009-04-03 08:28:38 +03001660 struct nfsd4_session *ses;
1661 u32 status = nfserr_badsession;
1662
1663 /* Notes:
1664 * - The confirmed nfs4_client->cl_sessionid holds destroyed sessinid
1665 * - Should we return nfserr_back_chan_busy if waiting for
1666 * callbacks on to-be-destroyed session?
1667 * - Do we need to clear any callback info from previous session?
1668 */
1669
J. Bruce Fields5d4cec22010-05-01 12:56:06 -04001670 if (nfsd4_compound_in_session(cstate->session, &sessionid->sessionid)) {
J. Bruce Fields57716352010-04-21 12:27:19 -04001671 if (!nfsd4_last_compound_op(r))
1672 return nfserr_not_only_op;
1673 }
Benny Halevye10e0cf2009-04-03 08:28:38 +03001674 dump_sessionid(__func__, &sessionid->sessionid);
Benny Halevy9089f1b2010-05-12 00:12:26 +03001675 spin_lock(&client_lock);
Benny Halevye10e0cf2009-04-03 08:28:38 +03001676 ses = find_in_sessionid_hashtbl(&sessionid->sessionid);
1677 if (!ses) {
Benny Halevy9089f1b2010-05-12 00:12:26 +03001678 spin_unlock(&client_lock);
Benny Halevye10e0cf2009-04-03 08:28:38 +03001679 goto out;
1680 }
1681
1682 unhash_session(ses);
Benny Halevy9089f1b2010-05-12 00:12:26 +03001683 spin_unlock(&client_lock);
Benny Halevye10e0cf2009-04-03 08:28:38 +03001684
Benny Halevyab707e152010-05-12 00:14:06 +03001685 nfs4_lock_state();
J. Bruce Fields84f5f7c2010-12-09 15:52:19 -05001686 nfsd4_probe_callback_sync(ses->se_client);
Benny Halevyab707e152010-05-12 00:14:06 +03001687 nfs4_unlock_state();
J. Bruce Fields19cf5c02010-06-06 18:37:16 -04001688
1689 nfsd4_del_conns(ses);
1690
Benny Halevye10e0cf2009-04-03 08:28:38 +03001691 nfsd4_put_session(ses);
1692 status = nfs_ok;
1693out:
1694 dprintk("%s returns %d\n", __func__, ntohl(status));
1695 return status;
Andy Adamson069b6ad2009-04-03 08:27:58 +03001696}
1697
J. Bruce Fieldsa663bdd2010-10-21 17:17:31 -04001698static struct nfsd4_conn *__nfsd4_find_conn(struct svc_xprt *xpt, struct nfsd4_session *s)
J. Bruce Fields328ead22010-09-29 16:11:06 -04001699{
1700 struct nfsd4_conn *c;
1701
1702 list_for_each_entry(c, &s->se_conns, cn_persession) {
J. Bruce Fieldsa663bdd2010-10-21 17:17:31 -04001703 if (c->cn_xprt == xpt) {
J. Bruce Fields328ead22010-09-29 16:11:06 -04001704 return c;
1705 }
1706 }
1707 return NULL;
1708}
1709
J. Bruce Fieldsa663bdd2010-10-21 17:17:31 -04001710static void nfsd4_sequence_check_conn(struct nfsd4_conn *new, struct nfsd4_session *ses)
J. Bruce Fields328ead22010-09-29 16:11:06 -04001711{
1712 struct nfs4_client *clp = ses->se_client;
J. Bruce Fieldsa663bdd2010-10-21 17:17:31 -04001713 struct nfsd4_conn *c;
J. Bruce Fields21b75b02010-10-26 10:07:17 -04001714 int ret;
J. Bruce Fields328ead22010-09-29 16:11:06 -04001715
1716 spin_lock(&clp->cl_lock);
J. Bruce Fieldsa663bdd2010-10-21 17:17:31 -04001717 c = __nfsd4_find_conn(new->cn_xprt, ses);
J. Bruce Fields328ead22010-09-29 16:11:06 -04001718 if (c) {
1719 spin_unlock(&clp->cl_lock);
1720 free_conn(new);
1721 return;
1722 }
1723 __nfsd4_hash_conn(new, ses);
1724 spin_unlock(&clp->cl_lock);
J. Bruce Fields21b75b02010-10-26 10:07:17 -04001725 ret = nfsd4_register_conn(new);
1726 if (ret)
1727 /* oops; xprt is already down: */
1728 nfsd4_conn_lost(&new->cn_xpt_user);
J. Bruce Fields328ead22010-09-29 16:11:06 -04001729 return;
1730}
1731
Mi Jinlong868b89c2011-04-27 09:09:58 +08001732static bool nfsd4_session_too_many_ops(struct svc_rqst *rqstp, struct nfsd4_session *session)
1733{
1734 struct nfsd4_compoundargs *args = rqstp->rq_argp;
1735
1736 return args->opcnt > session->se_fchannel.maxops;
1737}
1738
Andy Adamson069b6ad2009-04-03 08:27:58 +03001739__be32
Benny Halevyb85d4c02009-04-03 08:28:08 +03001740nfsd4_sequence(struct svc_rqst *rqstp,
Andy Adamson069b6ad2009-04-03 08:27:58 +03001741 struct nfsd4_compound_state *cstate,
1742 struct nfsd4_sequence *seq)
1743{
Andy Adamsonf9bb94c2009-04-03 08:28:12 +03001744 struct nfsd4_compoundres *resp = rqstp->rq_resp;
Benny Halevyb85d4c02009-04-03 08:28:08 +03001745 struct nfsd4_session *session;
1746 struct nfsd4_slot *slot;
J. Bruce Fieldsa663bdd2010-10-21 17:17:31 -04001747 struct nfsd4_conn *conn;
Benny Halevyb85d4c02009-04-03 08:28:08 +03001748 int status;
1749
Andy Adamsonf9bb94c2009-04-03 08:28:12 +03001750 if (resp->opcnt != 1)
1751 return nfserr_sequence_pos;
1752
J. Bruce Fieldsa663bdd2010-10-21 17:17:31 -04001753 /*
1754 * Will be either used or freed by nfsd4_sequence_check_conn
1755 * below.
1756 */
1757 conn = alloc_conn(rqstp, NFS4_CDFC4_FORE);
1758 if (!conn)
1759 return nfserr_jukebox;
1760
Benny Halevy9089f1b2010-05-12 00:12:26 +03001761 spin_lock(&client_lock);
Benny Halevyb85d4c02009-04-03 08:28:08 +03001762 status = nfserr_badsession;
1763 session = find_in_sessionid_hashtbl(&seq->sessionid);
1764 if (!session)
1765 goto out;
1766
Mi Jinlong868b89c2011-04-27 09:09:58 +08001767 status = nfserr_too_many_ops;
1768 if (nfsd4_session_too_many_ops(rqstp, session))
1769 goto out;
1770
Benny Halevyb85d4c02009-04-03 08:28:08 +03001771 status = nfserr_badslot;
Alexandros Batsakis6c18ba92009-06-16 04:19:13 +03001772 if (seq->slotid >= session->se_fchannel.maxreqs)
Benny Halevyb85d4c02009-04-03 08:28:08 +03001773 goto out;
1774
Andy Adamson557ce262009-08-28 08:45:04 -04001775 slot = session->se_slots[seq->slotid];
Benny Halevyb85d4c02009-04-03 08:28:08 +03001776 dprintk("%s: slotid %d\n", __func__, seq->slotid);
1777
Andy Adamsona8dfdae2009-08-28 08:45:02 -04001778 /* We do not negotiate the number of slots yet, so set the
1779 * maxslots to the session maxreqs which is used to encode
1780 * sr_highest_slotid and the sr_target_slot id to maxslots */
1781 seq->maxslots = session->se_fchannel.maxreqs;
1782
Andy Adamson88e588d2009-07-23 19:02:15 -04001783 status = check_slot_seqid(seq->seqid, slot->sl_seqid, slot->sl_inuse);
Benny Halevyb85d4c02009-04-03 08:28:08 +03001784 if (status == nfserr_replay_cache) {
1785 cstate->slot = slot;
1786 cstate->session = session;
Andy Adamsonda3846a2009-04-03 08:28:22 +03001787 /* Return the cached reply status and set cstate->status
Andy Adamson557ce262009-08-28 08:45:04 -04001788 * for nfsd4_proc_compound processing */
Andy Adamsonbf864a32009-04-03 08:28:35 +03001789 status = nfsd4_replay_cache_entry(resp, seq);
Andy Adamsonda3846a2009-04-03 08:28:22 +03001790 cstate->status = nfserr_replay_cache;
Benny Halevyaaf84eb2009-08-20 03:21:56 +03001791 goto out;
Benny Halevyb85d4c02009-04-03 08:28:08 +03001792 }
1793 if (status)
1794 goto out;
1795
J. Bruce Fieldsa663bdd2010-10-21 17:17:31 -04001796 nfsd4_sequence_check_conn(conn, session);
1797 conn = NULL;
J. Bruce Fields328ead22010-09-29 16:11:06 -04001798
Benny Halevyb85d4c02009-04-03 08:28:08 +03001799 /* Success! bump slot seqid */
1800 slot->sl_inuse = true;
1801 slot->sl_seqid = seq->seqid;
Andy Adamson557ce262009-08-28 08:45:04 -04001802 slot->sl_cachethis = seq->cachethis;
Benny Halevyb85d4c02009-04-03 08:28:08 +03001803
1804 cstate->slot = slot;
1805 cstate->session = session;
1806
Benny Halevyb85d4c02009-04-03 08:28:08 +03001807out:
J. Bruce Fields26c0c752010-04-24 15:35:43 -04001808 /* Hold a session reference until done processing the compound. */
Benny Halevyaaf84eb2009-08-20 03:21:56 +03001809 if (cstate->session) {
J. Bruce Fields0d7bb712010-11-18 08:30:33 -05001810 struct nfs4_client *clp = session->se_client;
1811
Benny Halevy36acb662010-05-12 00:13:04 +03001812 nfsd4_get_session(cstate->session);
J. Bruce Fields0d7bb712010-11-18 08:30:33 -05001813 atomic_inc(&clp->cl_refcount);
1814 if (clp->cl_cb_state == NFSD4_CB_DOWN)
1815 seq->status_flags |= SEQ4_STATUS_CB_PATH_DOWN;
Benny Halevyaaf84eb2009-08-20 03:21:56 +03001816 }
J. Bruce Fieldsa663bdd2010-10-21 17:17:31 -04001817 kfree(conn);
Benny Halevy36acb662010-05-12 00:13:04 +03001818 spin_unlock(&client_lock);
Benny Halevyb85d4c02009-04-03 08:28:08 +03001819 dprintk("%s: return %d\n", __func__, ntohl(status));
1820 return status;
Andy Adamson069b6ad2009-04-03 08:27:58 +03001821}
1822
1823__be32
J. Bruce Fields4dc6ec02010-04-19 15:11:28 -04001824nfsd4_reclaim_complete(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_reclaim_complete *rc)
1825{
Mi Jinlongbcecf1c2011-04-27 09:14:30 +08001826 int status = 0;
1827
J. Bruce Fields4dc6ec02010-04-19 15:11:28 -04001828 if (rc->rca_one_fs) {
1829 if (!cstate->current_fh.fh_dentry)
1830 return nfserr_nofilehandle;
1831 /*
1832 * We don't take advantage of the rca_one_fs case.
1833 * That's OK, it's optional, we can safely ignore it.
1834 */
1835 return nfs_ok;
1836 }
Mi Jinlongbcecf1c2011-04-27 09:14:30 +08001837
J. Bruce Fields4dc6ec02010-04-19 15:11:28 -04001838 nfs4_lock_state();
Mi Jinlongbcecf1c2011-04-27 09:14:30 +08001839 status = nfserr_complete_already;
1840 if (cstate->session->se_client->cl_firststate)
1841 goto out;
1842
1843 status = nfserr_stale_clientid;
1844 if (is_client_expired(cstate->session->se_client))
J. Bruce Fields4dc6ec02010-04-19 15:11:28 -04001845 /*
1846 * The following error isn't really legal.
1847 * But we only get here if the client just explicitly
1848 * destroyed the client. Surely it no longer cares what
1849 * error it gets back on an operation for the dead
1850 * client.
1851 */
Mi Jinlongbcecf1c2011-04-27 09:14:30 +08001852 goto out;
1853
1854 status = nfs_ok;
J. Bruce Fields4dc6ec02010-04-19 15:11:28 -04001855 nfsd4_create_clid_dir(cstate->session->se_client);
Mi Jinlongbcecf1c2011-04-27 09:14:30 +08001856out:
J. Bruce Fields4dc6ec02010-04-19 15:11:28 -04001857 nfs4_unlock_state();
Mi Jinlongbcecf1c2011-04-27 09:14:30 +08001858 return status;
J. Bruce Fields4dc6ec02010-04-19 15:11:28 -04001859}
1860
1861__be32
J.Bruce Fieldsb5914802006-12-13 00:35:38 -08001862nfsd4_setclientid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
1863 struct nfsd4_setclientid *setclid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001864{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001865 struct xdr_netobj clname = {
1866 .len = setclid->se_namelen,
1867 .data = setclid->se_name,
1868 };
1869 nfs4_verifier clverifier = setclid->se_verf;
1870 unsigned int strhashval;
NeilBrown28ce6052005-06-23 22:03:56 -07001871 struct nfs4_client *conf, *unconf, *new;
Al Virob37ad282006-10-19 23:28:59 -07001872 __be32 status;
NeilBrowna55370a2005-06-23 22:03:52 -07001873 char dname[HEXDIR_LEN];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001874
Linus Torvalds1da177e2005-04-16 15:20:36 -07001875 if (!check_name(clname))
Neil Brown73aea4e2005-09-13 01:25:39 -07001876 return nfserr_inval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001877
NeilBrowna55370a2005-06-23 22:03:52 -07001878 status = nfs4_make_rec_clidname(dname, &clname);
1879 if (status)
Neil Brown73aea4e2005-09-13 01:25:39 -07001880 return status;
NeilBrowna55370a2005-06-23 22:03:52 -07001881
Linus Torvalds1da177e2005-04-16 15:20:36 -07001882 /*
1883 * XXX The Duplicate Request Cache (DRC) has been checked (??)
1884 * We get here on a DRC miss.
1885 */
1886
NeilBrowna55370a2005-06-23 22:03:52 -07001887 strhashval = clientstr_hashval(dname);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001888
Linus Torvalds1da177e2005-04-16 15:20:36 -07001889 nfs4_lock_state();
J. Bruce Fieldse203d502010-11-24 17:30:54 -05001890 conf = find_confirmed_client_by_str(dname, strhashval);
NeilBrown28ce6052005-06-23 22:03:56 -07001891 if (conf) {
J. Bruce Fieldsa186e762007-11-20 16:11:27 -05001892 /* RFC 3530 14.2.33 CASE 0: */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001893 status = nfserr_clid_inuse;
J. Bruce Fieldse203d502010-11-24 17:30:54 -05001894 if (clp_used_exchangeid(conf))
1895 goto out;
J. Bruce Fields026722c2009-03-18 15:06:26 -04001896 if (!same_creds(&conf->cl_cred, &rqstp->rq_cred)) {
Jeff Layton363168b2009-08-14 12:57:56 -04001897 char addr_str[INET6_ADDRSTRLEN];
1898 rpc_ntop((struct sockaddr *) &conf->cl_addr, addr_str,
1899 sizeof(addr_str));
1900 dprintk("NFSD: setclientid: string in use by client "
1901 "at %s\n", addr_str);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001902 goto out;
1903 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001904 }
J. Bruce Fieldsa186e762007-11-20 16:11:27 -05001905 /*
1906 * section 14.2.33 of RFC 3530 (under the heading "IMPLEMENTATION")
1907 * has a description of SETCLIENTID request processing consisting
1908 * of 5 bullet points, labeled as CASE0 - CASE4 below.
1909 */
J. Bruce Fieldse203d502010-11-24 17:30:54 -05001910 unconf = find_unconfirmed_client_by_str(dname, strhashval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001911 status = nfserr_resource;
1912 if (!conf) {
J. Bruce Fieldsa186e762007-11-20 16:11:27 -05001913 /*
1914 * RFC 3530 14.2.33 CASE 4:
1915 * placed first, because it is the normal case
Linus Torvalds1da177e2005-04-16 15:20:36 -07001916 */
1917 if (unconf)
1918 expire_client(unconf);
Ricardo Labiagab09333c2009-09-10 12:27:34 +03001919 new = create_client(clname, dname, rqstp, &clverifier);
NeilBrowna55370a2005-06-23 22:03:52 -07001920 if (new == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001921 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001922 gen_clid(new);
J. Bruce Fields599e0a22007-07-26 17:04:54 -04001923 } else if (same_verf(&conf->cl_verifier, &clverifier)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001924 /*
J. Bruce Fieldsa186e762007-11-20 16:11:27 -05001925 * RFC 3530 14.2.33 CASE 1:
1926 * probable callback update
Linus Torvalds1da177e2005-04-16 15:20:36 -07001927 */
NeilBrown31f4a6c2005-06-23 22:04:06 -07001928 if (unconf) {
1929 /* Note this is removing unconfirmed {*x***},
1930 * which is stronger than RFC recommended {vxc**}.
1931 * This has the advantage that there is at most
1932 * one {*x***} in either list at any time.
1933 */
1934 expire_client(unconf);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001935 }
Ricardo Labiagab09333c2009-09-10 12:27:34 +03001936 new = create_client(clname, dname, rqstp, &clverifier);
NeilBrowna55370a2005-06-23 22:03:52 -07001937 if (new == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001938 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001939 copy_clid(new, conf);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001940 } else if (!unconf) {
1941 /*
J. Bruce Fieldsa186e762007-11-20 16:11:27 -05001942 * RFC 3530 14.2.33 CASE 2:
1943 * probable client reboot; state will be removed if
1944 * confirmed.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001945 */
Ricardo Labiagab09333c2009-09-10 12:27:34 +03001946 new = create_client(clname, dname, rqstp, &clverifier);
NeilBrowna55370a2005-06-23 22:03:52 -07001947 if (new == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001948 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001949 gen_clid(new);
J. Bruce Fields49ba8782007-11-19 19:09:50 -05001950 } else {
J. Bruce Fieldsa186e762007-11-20 16:11:27 -05001951 /*
1952 * RFC 3530 14.2.33 CASE 3:
1953 * probable client reboot; state will be removed if
1954 * confirmed.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001955 */
1956 expire_client(unconf);
Ricardo Labiagab09333c2009-09-10 12:27:34 +03001957 new = create_client(clname, dname, rqstp, &clverifier);
NeilBrowna55370a2005-06-23 22:03:52 -07001958 if (new == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001959 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001960 gen_clid(new);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001961 }
J. Bruce Fields8323c3b2010-10-19 19:36:51 -04001962 /*
1963 * XXX: we should probably set this at creation time, and check
1964 * for consistent minorversion use throughout:
1965 */
1966 new->cl_minorversion = 0;
Takuma Umeya6f3d7722010-12-15 14:09:01 +09001967 gen_callback(new, setclid, rqstp);
J. Bruce Fieldsc175b832007-08-09 18:34:32 -04001968 add_to_unconfirmed(new, strhashval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001969 setclid->se_clientid.cl_boot = new->cl_clientid.cl_boot;
1970 setclid->se_clientid.cl_id = new->cl_clientid.cl_id;
1971 memcpy(setclid->se_confirm.data, new->cl_confirm.data, sizeof(setclid->se_confirm.data));
1972 status = nfs_ok;
1973out:
1974 nfs4_unlock_state();
1975 return status;
1976}
1977
1978
1979/*
J. Bruce Fieldsa186e762007-11-20 16:11:27 -05001980 * Section 14.2.34 of RFC 3530 (under the heading "IMPLEMENTATION") has
1981 * a description of SETCLIENTID_CONFIRM request processing consisting of 4
1982 * bullets, labeled as CASE1 - CASE4 below.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001983 */
Al Virob37ad282006-10-19 23:28:59 -07001984__be32
J.Bruce Fieldsb5914802006-12-13 00:35:38 -08001985nfsd4_setclientid_confirm(struct svc_rqst *rqstp,
1986 struct nfsd4_compound_state *cstate,
1987 struct nfsd4_setclientid_confirm *setclientid_confirm)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001988{
Jeff Layton363168b2009-08-14 12:57:56 -04001989 struct sockaddr *sa = svc_addr(rqstp);
NeilBrown21ab45a2005-06-23 22:04:14 -07001990 struct nfs4_client *conf, *unconf;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001991 nfs4_verifier confirm = setclientid_confirm->sc_confirm;
1992 clientid_t * clid = &setclientid_confirm->sc_clientid;
Al Virob37ad282006-10-19 23:28:59 -07001993 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001994
1995 if (STALE_CLIENTID(clid))
1996 return nfserr_stale_clientid;
1997 /*
1998 * XXX The Duplicate Request Cache (DRC) has been checked (??)
1999 * We get here on a DRC miss.
2000 */
2001
2002 nfs4_lock_state();
NeilBrown21ab45a2005-06-23 22:04:14 -07002003
2004 conf = find_confirmed_client(clid);
2005 unconf = find_unconfirmed_client(clid);
2006
2007 status = nfserr_clid_inuse;
Jeff Layton363168b2009-08-14 12:57:56 -04002008 if (conf && !rpc_cmp_addr((struct sockaddr *) &conf->cl_addr, sa))
NeilBrown21ab45a2005-06-23 22:04:14 -07002009 goto out;
Jeff Layton363168b2009-08-14 12:57:56 -04002010 if (unconf && !rpc_cmp_addr((struct sockaddr *) &unconf->cl_addr, sa))
NeilBrown21ab45a2005-06-23 22:04:14 -07002011 goto out;
2012
J. Bruce Fieldsa186e762007-11-20 16:11:27 -05002013 /*
2014 * section 14.2.34 of RFC 3530 has a description of
2015 * SETCLIENTID_CONFIRM request processing consisting
2016 * of 4 bullet points, labeled as CASE1 - CASE4 below.
2017 */
J. Bruce Fields366e0c12007-11-20 15:54:10 -05002018 if (conf && unconf && same_verf(&confirm, &unconf->cl_confirm)) {
J. Bruce Fieldsa186e762007-11-20 16:11:27 -05002019 /*
2020 * RFC 3530 14.2.34 CASE 1:
2021 * callback update
2022 */
J. Bruce Fields599e0a22007-07-26 17:04:54 -04002023 if (!same_creds(&conf->cl_cred, &unconf->cl_cred))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002024 status = nfserr_clid_inuse;
2025 else {
J. Bruce Fields5a3c9d72010-10-19 17:56:52 -04002026 nfsd4_change_callback(conf, &unconf->cl_cb_conn);
2027 nfsd4_probe_callback(conf);
NeilBrown1a69c172005-06-23 22:04:08 -07002028 expire_client(unconf);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002029 status = nfs_ok;
NeilBrown1a69c172005-06-23 22:04:08 -07002030
Linus Torvalds1da177e2005-04-16 15:20:36 -07002031 }
J. Bruce Fieldsf3aba4e2007-11-20 16:52:07 -05002032 } else if (conf && !unconf) {
J. Bruce Fieldsa186e762007-11-20 16:11:27 -05002033 /*
2034 * RFC 3530 14.2.34 CASE 2:
2035 * probable retransmitted request; play it safe and
2036 * do nothing.
NeilBrown7c79f732005-06-23 22:04:13 -07002037 */
J. Bruce Fields599e0a22007-07-26 17:04:54 -04002038 if (!same_creds(&conf->cl_cred, &rqstp->rq_cred))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002039 status = nfserr_clid_inuse;
NeilBrown21ab45a2005-06-23 22:04:14 -07002040 else
Linus Torvalds1da177e2005-04-16 15:20:36 -07002041 status = nfs_ok;
NeilBrown7c79f732005-06-23 22:04:13 -07002042 } else if (!conf && unconf
J. Bruce Fields599e0a22007-07-26 17:04:54 -04002043 && same_verf(&unconf->cl_confirm, &confirm)) {
J. Bruce Fieldsa186e762007-11-20 16:11:27 -05002044 /*
2045 * RFC 3530 14.2.34 CASE 3:
2046 * Normal case; new or rebooted client:
NeilBrown7c79f732005-06-23 22:04:13 -07002047 */
J. Bruce Fields599e0a22007-07-26 17:04:54 -04002048 if (!same_creds(&unconf->cl_cred, &rqstp->rq_cred)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002049 status = nfserr_clid_inuse;
2050 } else {
NeilBrown1a69c172005-06-23 22:04:08 -07002051 unsigned int hash =
2052 clientstr_hashval(unconf->cl_recdir);
2053 conf = find_confirmed_client_by_str(unconf->cl_recdir,
J. Bruce Fieldse203d502010-11-24 17:30:54 -05002054 hash);
NeilBrown1a69c172005-06-23 22:04:08 -07002055 if (conf) {
NeilBrownc7b9a452005-06-23 22:04:30 -07002056 nfsd4_remove_clid_dir(conf);
NeilBrown1a69c172005-06-23 22:04:08 -07002057 expire_client(conf);
2058 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002059 move_to_confirmed(unconf);
NeilBrown21ab45a2005-06-23 22:04:14 -07002060 conf = unconf;
J. Bruce Fields5a3c9d72010-10-19 17:56:52 -04002061 nfsd4_probe_callback(conf);
NeilBrown1a69c172005-06-23 22:04:08 -07002062 status = nfs_ok;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002063 }
J. Bruce Fields599e0a22007-07-26 17:04:54 -04002064 } else if ((!conf || (conf && !same_verf(&conf->cl_confirm, &confirm)))
2065 && (!unconf || (unconf && !same_verf(&unconf->cl_confirm,
NeilBrown7c79f732005-06-23 22:04:13 -07002066 &confirm)))) {
J. Bruce Fieldsa186e762007-11-20 16:11:27 -05002067 /*
2068 * RFC 3530 14.2.34 CASE 4:
2069 * Client probably hasn't noticed that we rebooted yet.
NeilBrown7c79f732005-06-23 22:04:13 -07002070 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002071 status = nfserr_stale_clientid;
NeilBrown7c79f732005-06-23 22:04:13 -07002072 } else {
NeilBrown08e89872005-06-23 22:04:11 -07002073 /* check that we have hit one of the cases...*/
2074 status = nfserr_clid_inuse;
2075 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002076out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002077 nfs4_unlock_state();
2078 return status;
2079}
2080
Linus Torvalds1da177e2005-04-16 15:20:36 -07002081/* OPEN Share state helper functions */
2082static inline struct nfs4_file *
2083alloc_init_file(struct inode *ino)
2084{
2085 struct nfs4_file *fp;
2086 unsigned int hashval = file_hashval(ino);
2087
NeilBrowne60d4392005-06-23 22:03:01 -07002088 fp = kmem_cache_alloc(file_slab, GFP_KERNEL);
2089 if (fp) {
J. Bruce Fields8b671b82009-02-22 14:51:34 -08002090 atomic_set(&fp->fi_ref, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002091 INIT_LIST_HEAD(&fp->fi_hash);
NeilBrown8beefa22005-06-23 22:03:08 -07002092 INIT_LIST_HEAD(&fp->fi_stateids);
2093 INIT_LIST_HEAD(&fp->fi_delegations);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002094 fp->fi_inode = igrab(ino);
2095 fp->fi_id = current_fileid++;
Meelap Shah47f99402007-07-17 04:04:40 -07002096 fp->fi_had_conflict = false;
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05002097 fp->fi_lease = NULL;
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04002098 memset(fp->fi_fds, 0, sizeof(fp->fi_fds));
2099 memset(fp->fi_access, 0, sizeof(fp->fi_access));
Pavel Emelyanov47cee542010-05-17 20:00:37 +04002100 spin_lock(&recall_lock);
2101 list_add(&fp->fi_hash, &file_hashtbl[hashval]);
2102 spin_unlock(&recall_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002103 return fp;
2104 }
2105 return NULL;
2106}
2107
2108static void
Christoph Lametere18b8902006-12-06 20:33:20 -08002109nfsd4_free_slab(struct kmem_cache **slab)
NeilBrowne60d4392005-06-23 22:03:01 -07002110{
NeilBrowne60d4392005-06-23 22:03:01 -07002111 if (*slab == NULL)
2112 return;
Alexey Dobriyan1a1d92c2006-09-27 01:49:40 -07002113 kmem_cache_destroy(*slab);
NeilBrowne60d4392005-06-23 22:03:01 -07002114 *slab = NULL;
NeilBrowne60d4392005-06-23 22:03:01 -07002115}
2116
J. Bruce Fieldse8ff2a82007-08-01 15:30:59 -04002117void
NeilBrowne60d4392005-06-23 22:03:01 -07002118nfsd4_free_slabs(void)
2119{
2120 nfsd4_free_slab(&stateowner_slab);
2121 nfsd4_free_slab(&file_slab);
NeilBrown5ac049a2005-06-23 22:03:03 -07002122 nfsd4_free_slab(&stateid_slab);
NeilBrown5b2d21c2005-06-23 22:03:04 -07002123 nfsd4_free_slab(&deleg_slab);
NeilBrowne60d4392005-06-23 22:03:01 -07002124}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002125
2126static int
2127nfsd4_init_slabs(void)
2128{
2129 stateowner_slab = kmem_cache_create("nfsd4_stateowners",
Paul Mundt20c2df82007-07-20 10:11:58 +09002130 sizeof(struct nfs4_stateowner), 0, 0, NULL);
NeilBrowne60d4392005-06-23 22:03:01 -07002131 if (stateowner_slab == NULL)
2132 goto out_nomem;
2133 file_slab = kmem_cache_create("nfsd4_files",
Paul Mundt20c2df82007-07-20 10:11:58 +09002134 sizeof(struct nfs4_file), 0, 0, NULL);
NeilBrowne60d4392005-06-23 22:03:01 -07002135 if (file_slab == NULL)
2136 goto out_nomem;
NeilBrown5ac049a2005-06-23 22:03:03 -07002137 stateid_slab = kmem_cache_create("nfsd4_stateids",
Paul Mundt20c2df82007-07-20 10:11:58 +09002138 sizeof(struct nfs4_stateid), 0, 0, NULL);
NeilBrown5ac049a2005-06-23 22:03:03 -07002139 if (stateid_slab == NULL)
2140 goto out_nomem;
NeilBrown5b2d21c2005-06-23 22:03:04 -07002141 deleg_slab = kmem_cache_create("nfsd4_delegations",
Paul Mundt20c2df82007-07-20 10:11:58 +09002142 sizeof(struct nfs4_delegation), 0, 0, NULL);
NeilBrown5b2d21c2005-06-23 22:03:04 -07002143 if (deleg_slab == NULL)
2144 goto out_nomem;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002145 return 0;
NeilBrowne60d4392005-06-23 22:03:01 -07002146out_nomem:
2147 nfsd4_free_slabs();
2148 dprintk("nfsd4: out of memory while initializing nfsv4\n");
2149 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002150}
2151
2152void
2153nfs4_free_stateowner(struct kref *kref)
2154{
2155 struct nfs4_stateowner *sop =
2156 container_of(kref, struct nfs4_stateowner, so_ref);
2157 kfree(sop->so_owner.data);
2158 kmem_cache_free(stateowner_slab, sop);
2159}
2160
2161static inline struct nfs4_stateowner *
2162alloc_stateowner(struct xdr_netobj *owner)
2163{
2164 struct nfs4_stateowner *sop;
2165
2166 if ((sop = kmem_cache_alloc(stateowner_slab, GFP_KERNEL))) {
2167 if ((sop->so_owner.data = kmalloc(owner->len, GFP_KERNEL))) {
2168 memcpy(sop->so_owner.data, owner->data, owner->len);
2169 sop->so_owner.len = owner->len;
2170 kref_init(&sop->so_ref);
2171 return sop;
2172 }
2173 kmem_cache_free(stateowner_slab, sop);
2174 }
2175 return NULL;
2176}
2177
2178static struct nfs4_stateowner *
2179alloc_init_open_stateowner(unsigned int strhashval, struct nfs4_client *clp, struct nfsd4_open *open) {
2180 struct nfs4_stateowner *sop;
2181 struct nfs4_replay *rp;
2182 unsigned int idhashval;
2183
2184 if (!(sop = alloc_stateowner(&open->op_owner)))
2185 return NULL;
2186 idhashval = ownerid_hashval(current_ownerid);
2187 INIT_LIST_HEAD(&sop->so_idhash);
2188 INIT_LIST_HEAD(&sop->so_strhash);
2189 INIT_LIST_HEAD(&sop->so_perclient);
NeilBrownea1da632005-06-23 22:04:17 -07002190 INIT_LIST_HEAD(&sop->so_stateids);
2191 INIT_LIST_HEAD(&sop->so_perstateid); /* not used */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002192 INIT_LIST_HEAD(&sop->so_close_lru);
2193 sop->so_time = 0;
2194 list_add(&sop->so_idhash, &ownerid_hashtbl[idhashval]);
2195 list_add(&sop->so_strhash, &ownerstr_hashtbl[strhashval]);
NeilBrownea1da632005-06-23 22:04:17 -07002196 list_add(&sop->so_perclient, &clp->cl_openowners);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002197 sop->so_is_open_owner = 1;
2198 sop->so_id = current_ownerid++;
2199 sop->so_client = clp;
2200 sop->so_seqid = open->op_seqid;
2201 sop->so_confirmed = 0;
2202 rp = &sop->so_replay;
Al Virode1ae282006-01-18 17:43:47 -08002203 rp->rp_status = nfserr_serverfault;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002204 rp->rp_buflen = 0;
2205 rp->rp_buf = rp->rp_ibuf;
2206 return sop;
2207}
2208
Linus Torvalds1da177e2005-04-16 15:20:36 -07002209static inline void
2210init_stateid(struct nfs4_stateid *stp, struct nfs4_file *fp, struct nfsd4_open *open) {
2211 struct nfs4_stateowner *sop = open->op_stateowner;
2212 unsigned int hashval = stateid_hashval(sop->so_id, fp->fi_id);
2213
2214 INIT_LIST_HEAD(&stp->st_hash);
NeilBrownea1da632005-06-23 22:04:17 -07002215 INIT_LIST_HEAD(&stp->st_perstateowner);
2216 INIT_LIST_HEAD(&stp->st_lockowners);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002217 INIT_LIST_HEAD(&stp->st_perfile);
2218 list_add(&stp->st_hash, &stateid_hashtbl[hashval]);
NeilBrownea1da632005-06-23 22:04:17 -07002219 list_add(&stp->st_perstateowner, &sop->so_stateids);
NeilBrown8beefa22005-06-23 22:03:08 -07002220 list_add(&stp->st_perfile, &fp->fi_stateids);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002221 stp->st_stateowner = sop;
NeilBrown13cd2182005-06-23 22:03:10 -07002222 get_nfs4_file(fp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002223 stp->st_file = fp;
J. Bruce Fieldse4e83ea2010-04-22 16:21:39 -04002224 stp->st_stateid.si_boot = boot_time;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002225 stp->st_stateid.si_stateownerid = sop->so_id;
2226 stp->st_stateid.si_fileid = fp->fi_id;
2227 stp->st_stateid.si_generation = 0;
2228 stp->st_access_bmap = 0;
2229 stp->st_deny_bmap = 0;
Andy Adamson84459a12009-04-03 08:28:56 +03002230 __set_bit(open->op_share_access & ~NFS4_SHARE_WANT_MASK,
2231 &stp->st_access_bmap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002232 __set_bit(open->op_share_deny, &stp->st_deny_bmap);
NeilBrown4c4cd222005-07-07 17:59:27 -07002233 stp->st_openstp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002234}
2235
2236static void
Linus Torvalds1da177e2005-04-16 15:20:36 -07002237move_to_close_lru(struct nfs4_stateowner *sop)
2238{
2239 dprintk("NFSD: move_to_close_lru nfs4_stateowner %p\n", sop);
2240
NeilBrown358dd552006-04-10 22:55:42 -07002241 list_move_tail(&sop->so_close_lru, &close_lru);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002242 sop->so_time = get_seconds();
2243}
2244
Linus Torvalds1da177e2005-04-16 15:20:36 -07002245static int
J. Bruce Fields599e0a22007-07-26 17:04:54 -04002246same_owner_str(struct nfs4_stateowner *sop, struct xdr_netobj *owner,
2247 clientid_t *clid)
2248{
2249 return (sop->so_owner.len == owner->len) &&
2250 0 == memcmp(sop->so_owner.data, owner->data, owner->len) &&
2251 (sop->so_client->cl_clientid.cl_id == clid->cl_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002252}
2253
2254static struct nfs4_stateowner *
2255find_openstateowner_str(unsigned int hashval, struct nfsd4_open *open)
2256{
2257 struct nfs4_stateowner *so = NULL;
2258
2259 list_for_each_entry(so, &ownerstr_hashtbl[hashval], so_strhash) {
J. Bruce Fields599e0a22007-07-26 17:04:54 -04002260 if (same_owner_str(so, &open->op_owner, &open->op_clientid))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002261 return so;
2262 }
2263 return NULL;
2264}
2265
2266/* search file_hashtbl[] for file */
2267static struct nfs4_file *
2268find_file(struct inode *ino)
2269{
2270 unsigned int hashval = file_hashval(ino);
2271 struct nfs4_file *fp;
2272
J. Bruce Fields8b671b82009-02-22 14:51:34 -08002273 spin_lock(&recall_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002274 list_for_each_entry(fp, &file_hashtbl[hashval], fi_hash) {
NeilBrown13cd2182005-06-23 22:03:10 -07002275 if (fp->fi_inode == ino) {
2276 get_nfs4_file(fp);
J. Bruce Fields8b671b82009-02-22 14:51:34 -08002277 spin_unlock(&recall_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002278 return fp;
NeilBrown13cd2182005-06-23 22:03:10 -07002279 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002280 }
J. Bruce Fields8b671b82009-02-22 14:51:34 -08002281 spin_unlock(&recall_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002282 return NULL;
2283}
2284
Andy Adamsond87a8ad2009-04-03 08:28:53 +03002285static inline int access_valid(u32 x, u32 minorversion)
J. Bruce Fieldsba5a6a12006-06-30 01:56:16 -07002286{
Andy Adamsond87a8ad2009-04-03 08:28:53 +03002287 if ((x & NFS4_SHARE_ACCESS_MASK) < NFS4_SHARE_ACCESS_READ)
J. Bruce Fields8838dc42008-01-14 13:12:19 -05002288 return 0;
Andy Adamsond87a8ad2009-04-03 08:28:53 +03002289 if ((x & NFS4_SHARE_ACCESS_MASK) > NFS4_SHARE_ACCESS_BOTH)
2290 return 0;
2291 x &= ~NFS4_SHARE_ACCESS_MASK;
2292 if (minorversion && x) {
2293 if ((x & NFS4_SHARE_WANT_MASK) > NFS4_SHARE_WANT_CANCEL)
2294 return 0;
2295 if ((x & NFS4_SHARE_WHEN_MASK) > NFS4_SHARE_PUSH_DELEG_WHEN_UNCONTENDED)
2296 return 0;
2297 x &= ~(NFS4_SHARE_WANT_MASK | NFS4_SHARE_WHEN_MASK);
2298 }
2299 if (x)
J. Bruce Fields8838dc42008-01-14 13:12:19 -05002300 return 0;
2301 return 1;
J. Bruce Fieldsba5a6a12006-06-30 01:56:16 -07002302}
2303
J. Bruce Fields8838dc42008-01-14 13:12:19 -05002304static inline int deny_valid(u32 x)
J. Bruce Fieldsba5a6a12006-06-30 01:56:16 -07002305{
J. Bruce Fields8838dc42008-01-14 13:12:19 -05002306 /* Note: unlike access bits, deny bits may be zero. */
2307 return x <= NFS4_SHARE_DENY_BOTH;
J. Bruce Fieldsba5a6a12006-06-30 01:56:16 -07002308}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002309
J. Bruce Fields4f83aa32008-07-07 15:02:02 -04002310/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002311 * Called to check deny when READ with all zero stateid or
2312 * WRITE with all zero or all one stateid
2313 */
Al Virob37ad282006-10-19 23:28:59 -07002314static __be32
Linus Torvalds1da177e2005-04-16 15:20:36 -07002315nfs4_share_conflict(struct svc_fh *current_fh, unsigned int deny_type)
2316{
2317 struct inode *ino = current_fh->fh_dentry->d_inode;
2318 struct nfs4_file *fp;
2319 struct nfs4_stateid *stp;
Al Virob37ad282006-10-19 23:28:59 -07002320 __be32 ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002321
2322 dprintk("NFSD: nfs4_share_conflict\n");
2323
2324 fp = find_file(ino);
NeilBrown13cd2182005-06-23 22:03:10 -07002325 if (!fp)
2326 return nfs_ok;
NeilBrownb7009492005-07-07 17:59:23 -07002327 ret = nfserr_locked;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002328 /* Search for conflicting share reservations */
NeilBrown13cd2182005-06-23 22:03:10 -07002329 list_for_each_entry(stp, &fp->fi_stateids, st_perfile) {
2330 if (test_bit(deny_type, &stp->st_deny_bmap) ||
2331 test_bit(NFS4_SHARE_DENY_BOTH, &stp->st_deny_bmap))
2332 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002333 }
NeilBrown13cd2182005-06-23 22:03:10 -07002334 ret = nfs_ok;
2335out:
2336 put_nfs4_file(fp);
2337 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002338}
2339
2340static inline void
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04002341nfs4_file_downgrade(struct nfs4_file *fp, unsigned int share_access)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002342{
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04002343 if (share_access & NFS4_SHARE_ACCESS_WRITE)
2344 nfs4_file_put_access(fp, O_WRONLY);
2345 if (share_access & NFS4_SHARE_ACCESS_READ)
2346 nfs4_file_put_access(fp, O_RDONLY);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002347}
2348
J. Bruce Fields6b57d9c2011-01-31 11:54:04 -05002349static void nfsd_break_one_deleg(struct nfs4_delegation *dp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002350{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002351 /* We're assuming the state code never drops its reference
2352 * without first removing the lease. Since we're in this lease
2353 * callback (and since the lease code is serialized by the kernel
2354 * lock) we know the server hasn't removed the lease yet, we know
2355 * it's safe to take a reference: */
2356 atomic_inc(&dp->dl_count);
2357
Linus Torvalds1da177e2005-04-16 15:20:36 -07002358 list_add_tail(&dp->dl_recall_lru, &del_recall_lru);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002359
Arnd Bergmann460781b2010-11-17 16:26:56 +01002360 /* only place dl_time is set. protected by lock_flocks*/
Linus Torvalds1da177e2005-04-16 15:20:36 -07002361 dp->dl_time = get_seconds();
2362
J. Bruce Fields6b57d9c2011-01-31 11:54:04 -05002363 nfsd4_cb_recall(dp);
2364}
2365
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05002366/* Called from break_lease() with lock_flocks() held. */
J. Bruce Fields6b57d9c2011-01-31 11:54:04 -05002367static void nfsd_break_deleg_cb(struct file_lock *fl)
2368{
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05002369 struct nfs4_file *fp = (struct nfs4_file *)fl->fl_owner;
2370 struct nfs4_delegation *dp;
J. Bruce Fields6b57d9c2011-01-31 11:54:04 -05002371
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05002372 BUG_ON(!fp);
2373 /* We assume break_lease is only called once per lease: */
2374 BUG_ON(fp->fi_had_conflict);
J. Bruce Fields0272e1f2007-09-12 18:56:12 -04002375 /*
2376 * We don't want the locks code to timeout the lease for us;
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05002377 * we'll remove it ourself if a delegation isn't returned
J. Bruce Fields6b57d9c2011-01-31 11:54:04 -05002378 * in time:
J. Bruce Fields0272e1f2007-09-12 18:56:12 -04002379 */
2380 fl->fl_break_time = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002381
J. Bruce Fields5d926e82011-02-07 16:53:46 -05002382 spin_lock(&recall_lock);
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05002383 fp->fi_had_conflict = true;
2384 list_for_each_entry(dp, &fp->fi_delegations, dl_perfile)
2385 nfsd_break_one_deleg(dp);
J. Bruce Fields5d926e82011-02-07 16:53:46 -05002386 spin_unlock(&recall_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002387}
2388
Linus Torvalds1da177e2005-04-16 15:20:36 -07002389static
2390int nfsd_change_deleg_cb(struct file_lock **onlist, int arg)
2391{
2392 if (arg & F_UNLCK)
2393 return lease_modify(onlist, arg);
2394 else
2395 return -EAGAIN;
2396}
2397
Alexey Dobriyan7b021962009-09-21 17:01:12 -07002398static const struct lock_manager_operations nfsd_lease_mng_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002399 .fl_break = nfsd_break_deleg_cb,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002400 .fl_change = nfsd_change_deleg_cb,
2401};
2402
2403
Al Virob37ad282006-10-19 23:28:59 -07002404__be32
Andy Adamson66689582009-04-03 08:28:45 +03002405nfsd4_process_open1(struct nfsd4_compound_state *cstate,
2406 struct nfsd4_open *open)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002407{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002408 clientid_t *clientid = &open->op_clientid;
2409 struct nfs4_client *clp = NULL;
2410 unsigned int strhashval;
2411 struct nfs4_stateowner *sop = NULL;
2412
Linus Torvalds1da177e2005-04-16 15:20:36 -07002413 if (!check_name(open->op_owner))
J. Bruce Fields0f442aa2006-01-18 17:43:34 -08002414 return nfserr_inval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002415
2416 if (STALE_CLIENTID(&open->op_clientid))
2417 return nfserr_stale_clientid;
2418
2419 strhashval = ownerstr_hashval(clientid->cl_id, open->op_owner);
2420 sop = find_openstateowner_str(strhashval, open);
J. Bruce Fields0f442aa2006-01-18 17:43:34 -08002421 open->op_stateowner = sop;
2422 if (!sop) {
2423 /* Make sure the client's lease hasn't expired. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002424 clp = find_confirmed_client(clientid);
2425 if (clp == NULL)
J. Bruce Fields0f442aa2006-01-18 17:43:34 -08002426 return nfserr_expired;
2427 goto renew;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002428 }
Andy Adamson66689582009-04-03 08:28:45 +03002429 /* When sessions are used, skip open sequenceid processing */
2430 if (nfsd4_has_session(cstate))
2431 goto renew;
J. Bruce Fields0f442aa2006-01-18 17:43:34 -08002432 if (!sop->so_confirmed) {
2433 /* Replace unconfirmed owners without checking for replay. */
2434 clp = sop->so_client;
J. Bruce Fieldsf044ff82009-01-11 15:24:04 -05002435 release_openowner(sop);
J. Bruce Fields0f442aa2006-01-18 17:43:34 -08002436 open->op_stateowner = NULL;
2437 goto renew;
2438 }
2439 if (open->op_seqid == sop->so_seqid - 1) {
2440 if (sop->so_replay.rp_buflen)
Al Viroa90b0612006-10-19 23:29:03 -07002441 return nfserr_replay_me;
J. Bruce Fields0f442aa2006-01-18 17:43:34 -08002442 /* The original OPEN failed so spectacularly
2443 * that we don't even have replay data saved!
2444 * Therefore, we have no choice but to continue
2445 * processing this OPEN; presumably, we'll
2446 * fail again for the same reason.
2447 */
2448 dprintk("nfsd4_process_open1: replay with no replay cache\n");
2449 goto renew;
2450 }
2451 if (open->op_seqid != sop->so_seqid)
2452 return nfserr_bad_seqid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002453renew:
J. Bruce Fields0f442aa2006-01-18 17:43:34 -08002454 if (open->op_stateowner == NULL) {
2455 sop = alloc_init_open_stateowner(strhashval, clp, open);
2456 if (sop == NULL)
2457 return nfserr_resource;
2458 open->op_stateowner = sop;
2459 }
2460 list_del_init(&sop->so_close_lru);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002461 renew_client(sop->so_client);
J. Bruce Fields0f442aa2006-01-18 17:43:34 -08002462 return nfs_ok;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002463}
2464
Al Virob37ad282006-10-19 23:28:59 -07002465static inline __be32
NeilBrown4a6e43e2005-06-23 22:02:50 -07002466nfs4_check_delegmode(struct nfs4_delegation *dp, int flags)
2467{
2468 if ((flags & WR_STATE) && (dp->dl_type == NFS4_OPEN_DELEGATE_READ))
2469 return nfserr_openmode;
2470 else
2471 return nfs_ok;
2472}
2473
NeilBrown52f4fb42005-06-23 22:02:49 -07002474static struct nfs4_delegation *
2475find_delegation_file(struct nfs4_file *fp, stateid_t *stid)
2476{
J. Bruce Fields32b007b2011-03-06 19:11:03 -05002477 struct nfs4_delegation *dp;
NeilBrown52f4fb42005-06-23 22:02:49 -07002478
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05002479 spin_lock(&recall_lock);
J. Bruce Fields32b007b2011-03-06 19:11:03 -05002480 list_for_each_entry(dp, &fp->fi_delegations, dl_perfile)
2481 if (dp->dl_stateid.si_stateownerid == stid->si_stateownerid) {
2482 spin_unlock(&recall_lock);
2483 return dp;
2484 }
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05002485 spin_unlock(&recall_lock);
J. Bruce Fields32b007b2011-03-06 19:11:03 -05002486 return NULL;
NeilBrown52f4fb42005-06-23 22:02:49 -07002487}
2488
Daniel Mackc47d8322011-05-16 16:38:14 +02002489static int share_access_to_flags(u32 share_access)
J. Bruce Fields24a01112010-05-18 20:01:35 -04002490{
2491 share_access &= ~NFS4_SHARE_WANT_MASK;
2492
2493 return share_access == NFS4_SHARE_ACCESS_READ ? RD_STATE : WR_STATE;
2494}
2495
Al Virob37ad282006-10-19 23:28:59 -07002496static __be32
NeilBrown567d9822005-06-23 22:02:53 -07002497nfs4_check_deleg(struct nfs4_file *fp, struct nfsd4_open *open,
2498 struct nfs4_delegation **dp)
2499{
2500 int flags;
Al Virob37ad282006-10-19 23:28:59 -07002501 __be32 status = nfserr_bad_stateid;
NeilBrown567d9822005-06-23 22:02:53 -07002502
2503 *dp = find_delegation_file(fp, &open->op_delegate_stateid);
2504 if (*dp == NULL)
NeilBrownc44c5ee2005-06-23 22:02:54 -07002505 goto out;
J. Bruce Fields24a01112010-05-18 20:01:35 -04002506 flags = share_access_to_flags(open->op_share_access);
NeilBrown567d9822005-06-23 22:02:53 -07002507 status = nfs4_check_delegmode(*dp, flags);
2508 if (status)
2509 *dp = NULL;
NeilBrownc44c5ee2005-06-23 22:02:54 -07002510out:
2511 if (open->op_claim_type != NFS4_OPEN_CLAIM_DELEGATE_CUR)
2512 return nfs_ok;
2513 if (status)
2514 return status;
2515 open->op_stateowner->so_confirmed = 1;
2516 return nfs_ok;
NeilBrown567d9822005-06-23 22:02:53 -07002517}
2518
Al Virob37ad282006-10-19 23:28:59 -07002519static __be32
Linus Torvalds1da177e2005-04-16 15:20:36 -07002520nfs4_check_open(struct nfs4_file *fp, struct nfsd4_open *open, struct nfs4_stateid **stpp)
2521{
2522 struct nfs4_stateid *local;
Al Virob37ad282006-10-19 23:28:59 -07002523 __be32 status = nfserr_share_denied;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002524 struct nfs4_stateowner *sop = open->op_stateowner;
2525
NeilBrown8beefa22005-06-23 22:03:08 -07002526 list_for_each_entry(local, &fp->fi_stateids, st_perfile) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002527 /* ignore lock owners */
2528 if (local->st_stateowner->so_is_open_owner == 0)
2529 continue;
2530 /* remember if we have seen this open owner */
2531 if (local->st_stateowner == sop)
2532 *stpp = local;
2533 /* check for conflicting share reservations */
2534 if (!test_share(local, open))
2535 goto out;
2536 }
2537 status = 0;
2538out:
2539 return status;
2540}
2541
NeilBrown5ac049a2005-06-23 22:03:03 -07002542static inline struct nfs4_stateid *
2543nfs4_alloc_stateid(void)
2544{
2545 return kmem_cache_alloc(stateid_slab, GFP_KERNEL);
2546}
2547
J. Bruce Fields21fb4012010-07-28 12:21:23 -04002548static inline int nfs4_access_to_access(u32 nfs4_access)
2549{
2550 int flags = 0;
2551
2552 if (nfs4_access & NFS4_SHARE_ACCESS_READ)
2553 flags |= NFSD_MAY_READ;
2554 if (nfs4_access & NFS4_SHARE_ACCESS_WRITE)
2555 flags |= NFSD_MAY_WRITE;
2556 return flags;
2557}
2558
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04002559static __be32 nfs4_get_vfs_file(struct svc_rqst *rqstp, struct nfs4_file
2560*fp, struct svc_fh *cur_fh, u32 nfs4_access)
2561{
2562 __be32 status;
2563 int oflag = nfs4_access_to_omode(nfs4_access);
2564 int access = nfs4_access_to_access(nfs4_access);
2565
2566 if (!fp->fi_fds[oflag]) {
2567 status = nfsd_open(rqstp, cur_fh, S_IFREG, access,
2568 &fp->fi_fds[oflag]);
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04002569 if (status)
2570 return status;
2571 }
2572 nfs4_file_get_access(fp, oflag);
2573
2574 return nfs_ok;
2575}
2576
Al Virob37ad282006-10-19 23:28:59 -07002577static __be32
Linus Torvalds1da177e2005-04-16 15:20:36 -07002578nfs4_new_open(struct svc_rqst *rqstp, struct nfs4_stateid **stpp,
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04002579 struct nfs4_file *fp, struct svc_fh *cur_fh,
2580 struct nfsd4_open *open)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002581{
2582 struct nfs4_stateid *stp;
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04002583 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002584
NeilBrown5ac049a2005-06-23 22:03:03 -07002585 stp = nfs4_alloc_stateid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002586 if (stp == NULL)
2587 return nfserr_resource;
2588
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04002589 status = nfs4_get_vfs_file(rqstp, fp, cur_fh, open->op_share_access);
2590 if (status) {
2591 kmem_cache_free(stateid_slab, stp);
2592 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002593 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002594 *stpp = stp;
2595 return 0;
2596}
2597
Al Virob37ad282006-10-19 23:28:59 -07002598static inline __be32
Linus Torvalds1da177e2005-04-16 15:20:36 -07002599nfsd4_truncate(struct svc_rqst *rqstp, struct svc_fh *fh,
2600 struct nfsd4_open *open)
2601{
2602 struct iattr iattr = {
2603 .ia_valid = ATTR_SIZE,
2604 .ia_size = 0,
2605 };
2606 if (!open->op_truncate)
2607 return 0;
2608 if (!(open->op_share_access & NFS4_SHARE_ACCESS_WRITE))
Al Viro92465852006-01-18 17:43:46 -08002609 return nfserr_inval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002610 return nfsd_setattr(rqstp, fh, &iattr, 0, (time_t)0);
2611}
2612
Al Virob37ad282006-10-19 23:28:59 -07002613static __be32
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04002614nfs4_upgrade_open(struct svc_rqst *rqstp, struct nfs4_file *fp, struct svc_fh *cur_fh, struct nfs4_stateid *stp, struct nfsd4_open *open)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002615{
J. Bruce Fields7d947842010-08-20 18:09:31 -04002616 u32 op_share_access = open->op_share_access & ~NFS4_SHARE_WANT_MASK;
2617 bool new_access;
Al Virob37ad282006-10-19 23:28:59 -07002618 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002619
J. Bruce Fields7d947842010-08-20 18:09:31 -04002620 new_access = !test_bit(op_share_access, &stp->st_access_bmap);
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04002621 if (new_access) {
J. Bruce Fields7d947842010-08-20 18:09:31 -04002622 status = nfs4_get_vfs_file(rqstp, fp, cur_fh, op_share_access);
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04002623 if (status)
2624 return status;
J. Bruce Fields6c26d082006-01-18 17:43:38 -08002625 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002626 status = nfsd4_truncate(rqstp, cur_fh, open);
2627 if (status) {
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04002628 if (new_access) {
2629 int oflag = nfs4_access_to_omode(new_access);
2630 nfs4_file_put_access(fp, oflag);
2631 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002632 return status;
2633 }
2634 /* remember the open */
J. Bruce Fields24a01112010-05-18 20:01:35 -04002635 __set_bit(op_share_access, &stp->st_access_bmap);
J. Bruce Fieldsb55e0ba2008-04-28 18:22:50 -04002636 __set_bit(open->op_share_deny, &stp->st_deny_bmap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002637
2638 return nfs_ok;
2639}
2640
2641
Linus Torvalds1da177e2005-04-16 15:20:36 -07002642static void
NeilBrown37515172005-07-07 17:59:16 -07002643nfs4_set_claim_prev(struct nfsd4_open *open)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002644{
NeilBrown37515172005-07-07 17:59:16 -07002645 open->op_stateowner->so_confirmed = 1;
2646 open->op_stateowner->so_client->cl_firststate = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002647}
2648
J. Bruce Fields14a24e92010-12-10 19:02:49 -05002649/* Should we give out recallable state?: */
2650static bool nfsd4_cb_channel_good(struct nfs4_client *clp)
2651{
2652 if (clp->cl_cb_state == NFSD4_CB_UP)
2653 return true;
2654 /*
2655 * In the sessions case, since we don't have to establish a
2656 * separate connection for callbacks, we assume it's OK
2657 * until we hear otherwise:
2658 */
2659 return clp->cl_minorversion && clp->cl_cb_state == NFSD4_CB_UNKNOWN;
2660}
2661
J. Bruce Fields22d38c42011-01-31 11:55:12 -05002662static struct file_lock *nfs4_alloc_init_lease(struct nfs4_delegation *dp, int flag)
2663{
2664 struct file_lock *fl;
2665
2666 fl = locks_alloc_lock();
2667 if (!fl)
2668 return NULL;
2669 locks_init_lock(fl);
2670 fl->fl_lmops = &nfsd_lease_mng_ops;
2671 fl->fl_flags = FL_LEASE;
2672 fl->fl_type = flag == NFS4_OPEN_DELEGATE_READ? F_RDLCK: F_WRLCK;
2673 fl->fl_end = OFFSET_MAX;
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05002674 fl->fl_owner = (fl_owner_t)(dp->dl_file);
J. Bruce Fields22d38c42011-01-31 11:55:12 -05002675 fl->fl_pid = current->tgid;
J. Bruce Fields22d38c42011-01-31 11:55:12 -05002676 return fl;
2677}
2678
J. Bruce Fieldsedab9782011-01-31 17:58:10 -05002679static int nfs4_setlease(struct nfs4_delegation *dp, int flag)
2680{
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05002681 struct nfs4_file *fp = dp->dl_file;
J. Bruce Fieldsedab9782011-01-31 17:58:10 -05002682 struct file_lock *fl;
2683 int status;
2684
2685 fl = nfs4_alloc_init_lease(dp, flag);
2686 if (!fl)
2687 return -ENOMEM;
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05002688 fl->fl_file = find_readable_file(fp);
2689 list_add(&dp->dl_perclnt, &dp->dl_client->cl_delegations);
2690 status = vfs_setlease(fl->fl_file, fl->fl_type, &fl);
J. Bruce Fieldsedab9782011-01-31 17:58:10 -05002691 if (status) {
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05002692 list_del_init(&dp->dl_perclnt);
J. Bruce Fieldsedab9782011-01-31 17:58:10 -05002693 locks_free_lock(fl);
2694 return -ENOMEM;
2695 }
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05002696 fp->fi_lease = fl;
2697 fp->fi_deleg_file = fl->fl_file;
2698 get_file(fp->fi_deleg_file);
2699 atomic_set(&fp->fi_delegees, 1);
2700 list_add(&dp->dl_perfile, &fp->fi_delegations);
2701 return 0;
2702}
2703
2704static int nfs4_set_delegation(struct nfs4_delegation *dp, int flag)
2705{
2706 struct nfs4_file *fp = dp->dl_file;
2707
2708 if (!fp->fi_lease)
2709 return nfs4_setlease(dp, flag);
2710 spin_lock(&recall_lock);
2711 if (fp->fi_had_conflict) {
2712 spin_unlock(&recall_lock);
2713 return -EAGAIN;
2714 }
2715 atomic_inc(&fp->fi_delegees);
2716 list_add(&dp->dl_perfile, &fp->fi_delegations);
2717 spin_unlock(&recall_lock);
2718 list_add(&dp->dl_perclnt, &dp->dl_client->cl_delegations);
J. Bruce Fieldsedab9782011-01-31 17:58:10 -05002719 return 0;
2720}
2721
Linus Torvalds1da177e2005-04-16 15:20:36 -07002722/*
2723 * Attempt to hand out a delegation.
2724 */
2725static void
2726nfs4_open_delegation(struct svc_fh *fh, struct nfsd4_open *open, struct nfs4_stateid *stp)
2727{
2728 struct nfs4_delegation *dp;
2729 struct nfs4_stateowner *sop = stp->st_stateowner;
J. Bruce Fields14a24e92010-12-10 19:02:49 -05002730 int cb_up;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002731 int status, flag = 0;
2732
J. Bruce Fields14a24e92010-12-10 19:02:49 -05002733 cb_up = nfsd4_cb_channel_good(sop->so_client);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002734 flag = NFS4_OPEN_DELEGATE_NONE;
NeilBrown7b190fe2005-06-23 22:03:23 -07002735 open->op_recall = 0;
2736 switch (open->op_claim_type) {
2737 case NFS4_OPEN_CLAIM_PREVIOUS:
J. Bruce Fields2bf23872010-03-08 12:37:27 -05002738 if (!cb_up)
NeilBrown7b190fe2005-06-23 22:03:23 -07002739 open->op_recall = 1;
2740 flag = open->op_delegate_type;
2741 if (flag == NFS4_OPEN_DELEGATE_NONE)
2742 goto out;
2743 break;
2744 case NFS4_OPEN_CLAIM_NULL:
2745 /* Let's not give out any delegations till everyone's
2746 * had the chance to reclaim theirs.... */
J. Bruce Fieldsaf558e32007-09-06 12:34:25 -04002747 if (locks_in_grace())
NeilBrown7b190fe2005-06-23 22:03:23 -07002748 goto out;
J. Bruce Fields2bf23872010-03-08 12:37:27 -05002749 if (!cb_up || !sop->so_confirmed)
NeilBrown7b190fe2005-06-23 22:03:23 -07002750 goto out;
2751 if (open->op_share_access & NFS4_SHARE_ACCESS_WRITE)
2752 flag = NFS4_OPEN_DELEGATE_WRITE;
2753 else
2754 flag = NFS4_OPEN_DELEGATE_READ;
2755 break;
2756 default:
2757 goto out;
2758 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002759
2760 dp = alloc_init_deleg(sop->so_client, stp, fh, flag);
J. Bruce Fieldsdd239cc2011-01-31 17:14:55 -05002761 if (dp == NULL)
2762 goto out_no_deleg;
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05002763 status = nfs4_set_delegation(dp, flag);
J. Bruce Fieldsedab9782011-01-31 17:58:10 -05002764 if (status)
J. Bruce Fieldsdd239cc2011-01-31 17:14:55 -05002765 goto out_free;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002766
2767 memcpy(&open->op_delegate_stateid, &dp->dl_stateid, sizeof(dp->dl_stateid));
2768
Benny Halevy8c10cbd2009-10-19 12:04:53 +02002769 dprintk("NFSD: delegation stateid=" STATEID_FMT "\n",
2770 STATEID_VAL(&dp->dl_stateid));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002771out:
NeilBrown7b190fe2005-06-23 22:03:23 -07002772 if (open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS
2773 && flag == NFS4_OPEN_DELEGATE_NONE
2774 && open->op_delegate_type != NFS4_OPEN_DELEGATE_NONE)
J. Bruce Fields2fdada02007-07-27 16:10:37 -04002775 dprintk("NFSD: WARNING: refusing delegation reclaim\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002776 open->op_delegate_type = flag;
J. Bruce Fieldsdd239cc2011-01-31 17:14:55 -05002777 return;
2778out_free:
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05002779 nfs4_put_delegation(dp);
J. Bruce Fieldsdd239cc2011-01-31 17:14:55 -05002780out_no_deleg:
2781 flag = NFS4_OPEN_DELEGATE_NONE;
2782 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002783}
2784
2785/*
2786 * called with nfs4_lock_state() held.
2787 */
Al Virob37ad282006-10-19 23:28:59 -07002788__be32
Linus Torvalds1da177e2005-04-16 15:20:36 -07002789nfsd4_process_open2(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_open *open)
2790{
Andy Adamson66689582009-04-03 08:28:45 +03002791 struct nfsd4_compoundres *resp = rqstp->rq_resp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002792 struct nfs4_file *fp = NULL;
2793 struct inode *ino = current_fh->fh_dentry->d_inode;
2794 struct nfs4_stateid *stp = NULL;
NeilBrown567d9822005-06-23 22:02:53 -07002795 struct nfs4_delegation *dp = NULL;
Al Virob37ad282006-10-19 23:28:59 -07002796 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002797
2798 status = nfserr_inval;
Andy Adamsond87a8ad2009-04-03 08:28:53 +03002799 if (!access_valid(open->op_share_access, resp->cstate.minorversion)
J. Bruce Fieldsba5a6a12006-06-30 01:56:16 -07002800 || !deny_valid(open->op_share_deny))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002801 goto out;
2802 /*
2803 * Lookup file; if found, lookup stateid and check open request,
2804 * and check for delegations in the process of being recalled.
2805 * If not found, create the nfs4_file struct
2806 */
2807 fp = find_file(ino);
2808 if (fp) {
2809 if ((status = nfs4_check_open(fp, open, &stp)))
2810 goto out;
NeilBrownc44c5ee2005-06-23 22:02:54 -07002811 status = nfs4_check_deleg(fp, open, &dp);
2812 if (status)
2813 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002814 } else {
NeilBrownc44c5ee2005-06-23 22:02:54 -07002815 status = nfserr_bad_stateid;
2816 if (open->op_claim_type == NFS4_OPEN_CLAIM_DELEGATE_CUR)
2817 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002818 status = nfserr_resource;
2819 fp = alloc_init_file(ino);
2820 if (fp == NULL)
2821 goto out;
2822 }
2823
2824 /*
2825 * OPEN the file, or upgrade an existing OPEN.
2826 * If truncate fails, the OPEN fails.
2827 */
2828 if (stp) {
2829 /* Stateid was found, this is an OPEN upgrade */
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04002830 status = nfs4_upgrade_open(rqstp, fp, current_fh, stp, open);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002831 if (status)
2832 goto out;
NeilBrown444c2c02005-07-07 17:59:22 -07002833 update_stateid(&stp->st_stateid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002834 } else {
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04002835 status = nfs4_new_open(rqstp, &stp, fp, current_fh, open);
NeilBrown567d9822005-06-23 22:02:53 -07002836 if (status)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002837 goto out;
2838 init_stateid(stp, fp, open);
2839 status = nfsd4_truncate(rqstp, current_fh, open);
2840 if (status) {
J. Bruce Fields22839632009-01-11 14:27:17 -05002841 release_open_stateid(stp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002842 goto out;
2843 }
Andy Adamson66689582009-04-03 08:28:45 +03002844 if (nfsd4_has_session(&resp->cstate))
2845 update_stateid(&stp->st_stateid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002846 }
2847 memcpy(&open->op_stateid, &stp->st_stateid, sizeof(stateid_t));
2848
J. Bruce Fields4dc6ec02010-04-19 15:11:28 -04002849 if (nfsd4_has_session(&resp->cstate))
Andy Adamson66689582009-04-03 08:28:45 +03002850 open->op_stateowner->so_confirmed = 1;
2851
Linus Torvalds1da177e2005-04-16 15:20:36 -07002852 /*
2853 * Attempt to hand out a delegation. No error return, because the
2854 * OPEN succeeds even if we fail.
2855 */
2856 nfs4_open_delegation(current_fh, open, stp);
2857
2858 status = nfs_ok;
2859
Benny Halevy8c10cbd2009-10-19 12:04:53 +02002860 dprintk("%s: stateid=" STATEID_FMT "\n", __func__,
2861 STATEID_VAL(&stp->st_stateid));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002862out:
NeilBrown13cd2182005-06-23 22:03:10 -07002863 if (fp)
2864 put_nfs4_file(fp);
NeilBrown37515172005-07-07 17:59:16 -07002865 if (status == 0 && open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS)
2866 nfs4_set_claim_prev(open);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002867 /*
2868 * To finish the open response, we just need to set the rflags.
2869 */
2870 open->op_rflags = NFS4_OPEN_RESULT_LOCKTYPE_POSIX;
Andy Adamson66689582009-04-03 08:28:45 +03002871 if (!open->op_stateowner->so_confirmed &&
2872 !nfsd4_has_session(&resp->cstate))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002873 open->op_rflags |= NFS4_OPEN_RESULT_CONFIRM;
2874
2875 return status;
2876}
2877
Al Virob37ad282006-10-19 23:28:59 -07002878__be32
J.Bruce Fieldsb5914802006-12-13 00:35:38 -08002879nfsd4_renew(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
2880 clientid_t *clid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002881{
2882 struct nfs4_client *clp;
Al Virob37ad282006-10-19 23:28:59 -07002883 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002884
2885 nfs4_lock_state();
2886 dprintk("process_renew(%08x/%08x): starting\n",
2887 clid->cl_boot, clid->cl_id);
2888 status = nfserr_stale_clientid;
2889 if (STALE_CLIENTID(clid))
2890 goto out;
2891 clp = find_confirmed_client(clid);
2892 status = nfserr_expired;
2893 if (clp == NULL) {
2894 /* We assume the client took too long to RENEW. */
2895 dprintk("nfsd4_renew: clientid not found!\n");
2896 goto out;
2897 }
2898 renew_client(clp);
2899 status = nfserr_cb_path_down;
NeilBrownea1da632005-06-23 22:04:17 -07002900 if (!list_empty(&clp->cl_delegations)
J. Bruce Fields77a35692010-04-30 18:51:44 -04002901 && clp->cl_cb_state != NFSD4_CB_UP)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002902 goto out;
2903 status = nfs_ok;
2904out:
2905 nfs4_unlock_state();
2906 return status;
2907}
2908
Daniel Mackc47d8322011-05-16 16:38:14 +02002909static struct lock_manager nfsd4_manager = {
J. Bruce Fieldsaf558e32007-09-06 12:34:25 -04002910};
2911
NeilBrowna76b4312005-06-23 22:04:01 -07002912static void
J. Bruce Fieldsaf558e32007-09-06 12:34:25 -04002913nfsd4_end_grace(void)
NeilBrowna76b4312005-06-23 22:04:01 -07002914{
2915 dprintk("NFSD: end of grace period\n");
NeilBrownc7b9a452005-06-23 22:04:30 -07002916 nfsd4_recdir_purge_old();
J. Bruce Fieldsaf558e32007-09-06 12:34:25 -04002917 locks_end_grace(&nfsd4_manager);
J. Bruce Fieldse46b4982010-03-01 19:21:21 -05002918 /*
2919 * Now that every NFSv4 client has had the chance to recover and
2920 * to see the (possibly new, possibly shorter) lease time, we
2921 * can safely set the next grace time to the current lease time:
2922 */
2923 nfsd4_grace = nfsd4_lease;
NeilBrowna76b4312005-06-23 22:04:01 -07002924}
2925
NeilBrownfd39ca92005-06-23 22:04:03 -07002926static time_t
Linus Torvalds1da177e2005-04-16 15:20:36 -07002927nfs4_laundromat(void)
2928{
2929 struct nfs4_client *clp;
2930 struct nfs4_stateowner *sop;
2931 struct nfs4_delegation *dp;
2932 struct list_head *pos, *next, reaplist;
J. Bruce Fieldscf07d2e2010-02-28 23:20:19 -05002933 time_t cutoff = get_seconds() - nfsd4_lease;
2934 time_t t, clientid_val = nfsd4_lease;
2935 time_t u, test_val = nfsd4_lease;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002936
2937 nfs4_lock_state();
2938
2939 dprintk("NFSD: laundromat service - starting\n");
J. Bruce Fieldsaf558e32007-09-06 12:34:25 -04002940 if (locks_in_grace())
2941 nfsd4_end_grace();
Benny Halevy36acb662010-05-12 00:13:04 +03002942 INIT_LIST_HEAD(&reaplist);
2943 spin_lock(&client_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002944 list_for_each_safe(pos, next, &client_lru) {
2945 clp = list_entry(pos, struct nfs4_client, cl_lru);
2946 if (time_after((unsigned long)clp->cl_time, (unsigned long)cutoff)) {
2947 t = clp->cl_time - cutoff;
2948 if (clientid_val > t)
2949 clientid_val = t;
2950 break;
2951 }
Benny Halevyd7682982010-05-12 00:13:54 +03002952 if (atomic_read(&clp->cl_refcount)) {
2953 dprintk("NFSD: client in use (clientid %08x)\n",
2954 clp->cl_clientid.cl_id);
2955 continue;
2956 }
2957 unhash_client_locked(clp);
2958 list_add(&clp->cl_lru, &reaplist);
Benny Halevy36acb662010-05-12 00:13:04 +03002959 }
2960 spin_unlock(&client_lock);
2961 list_for_each_safe(pos, next, &reaplist) {
2962 clp = list_entry(pos, struct nfs4_client, cl_lru);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002963 dprintk("NFSD: purging unused client (clientid %08x)\n",
2964 clp->cl_clientid.cl_id);
NeilBrownc7b9a452005-06-23 22:04:30 -07002965 nfsd4_remove_clid_dir(clp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002966 expire_client(clp);
2967 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002968 spin_lock(&recall_lock);
2969 list_for_each_safe(pos, next, &del_recall_lru) {
2970 dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
2971 if (time_after((unsigned long)dp->dl_time, (unsigned long)cutoff)) {
2972 u = dp->dl_time - cutoff;
2973 if (test_val > u)
2974 test_val = u;
2975 break;
2976 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002977 list_move(&dp->dl_recall_lru, &reaplist);
2978 }
2979 spin_unlock(&recall_lock);
2980 list_for_each_safe(pos, next, &reaplist) {
2981 dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
2982 list_del_init(&dp->dl_recall_lru);
2983 unhash_delegation(dp);
2984 }
J. Bruce Fieldscf07d2e2010-02-28 23:20:19 -05002985 test_val = nfsd4_lease;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002986 list_for_each_safe(pos, next, &close_lru) {
2987 sop = list_entry(pos, struct nfs4_stateowner, so_close_lru);
2988 if (time_after((unsigned long)sop->so_time, (unsigned long)cutoff)) {
2989 u = sop->so_time - cutoff;
2990 if (test_val > u)
2991 test_val = u;
2992 break;
2993 }
2994 dprintk("NFSD: purging unused open stateowner (so_id %d)\n",
2995 sop->so_id);
J. Bruce Fieldsf044ff82009-01-11 15:24:04 -05002996 release_openowner(sop);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002997 }
2998 if (clientid_val < NFSD_LAUNDROMAT_MINTIMEOUT)
2999 clientid_val = NFSD_LAUNDROMAT_MINTIMEOUT;
3000 nfs4_unlock_state();
3001 return clientid_val;
3002}
3003
Harvey Harrisona254b242008-02-20 12:49:00 -08003004static struct workqueue_struct *laundry_wq;
3005static void laundromat_main(struct work_struct *);
3006static DECLARE_DELAYED_WORK(laundromat_work, laundromat_main);
3007
3008static void
David Howellsc4028952006-11-22 14:57:56 +00003009laundromat_main(struct work_struct *not_used)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003010{
3011 time_t t;
3012
3013 t = nfs4_laundromat();
3014 dprintk("NFSD: laundromat_main - sleeping for %ld seconds\n", t);
NeilBrown58da2822005-06-23 22:03:19 -07003015 queue_delayed_work(laundry_wq, &laundromat_work, t*HZ);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003016}
3017
NeilBrownfd39ca92005-06-23 22:04:03 -07003018static struct nfs4_stateowner *
NeilBrownf8816512005-07-07 17:59:25 -07003019search_close_lru(u32 st_id, int flags)
3020{
Linus Torvalds1da177e2005-04-16 15:20:36 -07003021 struct nfs4_stateowner *local = NULL;
3022
Linus Torvalds1da177e2005-04-16 15:20:36 -07003023 if (flags & CLOSE_STATE) {
3024 list_for_each_entry(local, &close_lru, so_close_lru) {
3025 if (local->so_id == st_id)
3026 return local;
3027 }
3028 }
3029 return NULL;
3030}
3031
3032static inline int
3033nfs4_check_fh(struct svc_fh *fhp, struct nfs4_stateid *stp)
3034{
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04003035 return fhp->fh_dentry->d_inode != stp->st_file->fi_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003036}
3037
3038static int
3039STALE_STATEID(stateid_t *stateid)
3040{
J. Bruce Fieldse4e83ea2010-04-22 16:21:39 -04003041 if (stateid->si_boot == boot_time)
3042 return 0;
3043 dprintk("NFSD: stale stateid " STATEID_FMT "!\n",
Benny Halevy8c10cbd2009-10-19 12:04:53 +02003044 STATEID_VAL(stateid));
J. Bruce Fieldse4e83ea2010-04-22 16:21:39 -04003045 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003046}
3047
3048static inline int
3049access_permit_read(unsigned long access_bmap)
3050{
3051 return test_bit(NFS4_SHARE_ACCESS_READ, &access_bmap) ||
3052 test_bit(NFS4_SHARE_ACCESS_BOTH, &access_bmap) ||
3053 test_bit(NFS4_SHARE_ACCESS_WRITE, &access_bmap);
3054}
3055
3056static inline int
3057access_permit_write(unsigned long access_bmap)
3058{
3059 return test_bit(NFS4_SHARE_ACCESS_WRITE, &access_bmap) ||
3060 test_bit(NFS4_SHARE_ACCESS_BOTH, &access_bmap);
3061}
3062
3063static
Al Virob37ad282006-10-19 23:28:59 -07003064__be32 nfs4_check_openmode(struct nfs4_stateid *stp, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003065{
Al Virob37ad282006-10-19 23:28:59 -07003066 __be32 status = nfserr_openmode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003067
J. Bruce Fields02921912010-07-29 15:16:59 -04003068 /* For lock stateid's, we test the parent open, not the lock: */
3069 if (stp->st_openstp)
3070 stp = stp->st_openstp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003071 if ((flags & WR_STATE) && (!access_permit_write(stp->st_access_bmap)))
3072 goto out;
3073 if ((flags & RD_STATE) && (!access_permit_read(stp->st_access_bmap)))
3074 goto out;
3075 status = nfs_ok;
3076out:
3077 return status;
3078}
3079
Al Virob37ad282006-10-19 23:28:59 -07003080static inline __be32
Linus Torvalds1da177e2005-04-16 15:20:36 -07003081check_special_stateids(svc_fh *current_fh, stateid_t *stateid, int flags)
3082{
J. Bruce Fields203a8c82009-02-21 13:29:14 -08003083 if (ONE_STATEID(stateid) && (flags & RD_STATE))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003084 return nfs_ok;
J. Bruce Fieldsaf558e32007-09-06 12:34:25 -04003085 else if (locks_in_grace()) {
Lucas De Marchi25985ed2011-03-30 22:57:33 -03003086 /* Answer in remaining cases depends on existence of
Linus Torvalds1da177e2005-04-16 15:20:36 -07003087 * conflicting state; so we must wait out the grace period. */
3088 return nfserr_grace;
3089 } else if (flags & WR_STATE)
3090 return nfs4_share_conflict(current_fh,
3091 NFS4_SHARE_DENY_WRITE);
3092 else /* (flags & RD_STATE) && ZERO_STATEID(stateid) */
3093 return nfs4_share_conflict(current_fh,
3094 NFS4_SHARE_DENY_READ);
3095}
3096
3097/*
3098 * Allow READ/WRITE during grace period on recovered state only for files
3099 * that are not able to provide mandatory locking.
3100 */
3101static inline int
J. Bruce Fields18f82732009-02-21 15:23:01 -08003102grace_disallows_io(struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003103{
J. Bruce Fields203a8c82009-02-21 13:29:14 -08003104 return locks_in_grace() && mandatory_lock(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003105}
3106
Andy Adamson66689582009-04-03 08:28:45 +03003107static int check_stateid_generation(stateid_t *in, stateid_t *ref, int flags)
J. Bruce Fields0836f582008-01-26 19:08:12 -05003108{
Andy Adamson66689582009-04-03 08:28:45 +03003109 /*
3110 * When sessions are used the stateid generation number is ignored
3111 * when it is zero.
3112 */
3113 if ((flags & HAS_SESSION) && in->si_generation == 0)
3114 goto out;
3115
J. Bruce Fields0836f582008-01-26 19:08:12 -05003116 /* If the client sends us a stateid from the future, it's buggy: */
3117 if (in->si_generation > ref->si_generation)
3118 return nfserr_bad_stateid;
3119 /*
3120 * The following, however, can happen. For example, if the
3121 * client sends an open and some IO at the same time, the open
3122 * may bump si_generation while the IO is still in flight.
3123 * Thanks to hard links and renames, the client never knows what
3124 * file an open will affect. So it could avoid that situation
3125 * only by serializing all opens and IO from the same open
3126 * owner. To recover from the old_stateid error, the client
3127 * will just have to retry the IO:
3128 */
3129 if (in->si_generation < ref->si_generation)
3130 return nfserr_old_stateid;
Andy Adamson66689582009-04-03 08:28:45 +03003131out:
J. Bruce Fields0836f582008-01-26 19:08:12 -05003132 return nfs_ok;
3133}
3134
J. Bruce Fields3e633072009-02-21 13:17:19 -08003135static int is_delegation_stateid(stateid_t *stateid)
3136{
3137 return stateid->si_fileid == 0;
3138}
3139
Linus Torvalds1da177e2005-04-16 15:20:36 -07003140/*
3141* Checks for stateid operations
3142*/
Al Virob37ad282006-10-19 23:28:59 -07003143__be32
Benny Halevydd453df2009-04-03 08:28:41 +03003144nfs4_preprocess_stateid_op(struct nfsd4_compound_state *cstate,
3145 stateid_t *stateid, int flags, struct file **filpp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003146{
3147 struct nfs4_stateid *stp = NULL;
3148 struct nfs4_delegation *dp = NULL;
Benny Halevydd453df2009-04-03 08:28:41 +03003149 struct svc_fh *current_fh = &cstate->current_fh;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003150 struct inode *ino = current_fh->fh_dentry->d_inode;
Al Virob37ad282006-10-19 23:28:59 -07003151 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003152
Linus Torvalds1da177e2005-04-16 15:20:36 -07003153 if (filpp)
3154 *filpp = NULL;
3155
J. Bruce Fields18f82732009-02-21 15:23:01 -08003156 if (grace_disallows_io(ino))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003157 return nfserr_grace;
3158
Andy Adamson66689582009-04-03 08:28:45 +03003159 if (nfsd4_has_session(cstate))
3160 flags |= HAS_SESSION;
3161
Linus Torvalds1da177e2005-04-16 15:20:36 -07003162 if (ZERO_STATEID(stateid) || ONE_STATEID(stateid))
3163 return check_special_stateids(current_fh, stateid, flags);
3164
Linus Torvalds1da177e2005-04-16 15:20:36 -07003165 status = nfserr_stale_stateid;
3166 if (STALE_STATEID(stateid))
3167 goto out;
3168
J. Bruce Fields33515142010-10-02 18:42:39 -04003169 /*
3170 * We assume that any stateid that has the current boot time,
3171 * but that we can't find, is expired:
3172 */
3173 status = nfserr_expired;
J. Bruce Fields3e633072009-02-21 13:17:19 -08003174 if (is_delegation_stateid(stateid)) {
J. Bruce Fieldsa4455be2009-02-21 10:40:22 -08003175 dp = find_delegation_stateid(ino, stateid);
J. Bruce Fieldse4e83ea2010-04-22 16:21:39 -04003176 if (!dp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003177 goto out;
Andy Adamson66689582009-04-03 08:28:45 +03003178 status = check_stateid_generation(stateid, &dp->dl_stateid,
3179 flags);
J. Bruce Fields0c2a4982009-02-21 11:11:50 -08003180 if (status)
3181 goto out;
J. Bruce Fieldsdc9bf702009-02-21 11:14:43 -08003182 status = nfs4_check_delegmode(dp, flags);
3183 if (status)
3184 goto out;
3185 renew_client(dp->dl_client);
Dan Carpenter43b01782010-10-27 23:19:04 +02003186 if (filpp) {
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05003187 *filpp = dp->dl_file->fi_deleg_file;
Dan Carpenter43b01782010-10-27 23:19:04 +02003188 BUG_ON(!*filpp);
3189 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003190 } else { /* open or lock stateid */
J. Bruce Fieldsa4455be2009-02-21 10:40:22 -08003191 stp = find_stateid(stateid, flags);
J. Bruce Fieldse4e83ea2010-04-22 16:21:39 -04003192 if (!stp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003193 goto out;
J. Bruce Fields33515142010-10-02 18:42:39 -04003194 status = nfserr_bad_stateid;
J. Bruce Fields6150ef02009-02-21 13:36:16 -08003195 if (nfs4_check_fh(current_fh, stp))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003196 goto out;
3197 if (!stp->st_stateowner->so_confirmed)
3198 goto out;
Andy Adamson66689582009-04-03 08:28:45 +03003199 status = check_stateid_generation(stateid, &stp->st_stateid,
3200 flags);
J. Bruce Fields0c2a4982009-02-21 11:11:50 -08003201 if (status)
3202 goto out;
J. Bruce Fieldsa4455be2009-02-21 10:40:22 -08003203 status = nfs4_check_openmode(stp, flags);
3204 if (status)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003205 goto out;
3206 renew_client(stp->st_stateowner->so_client);
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04003207 if (filpp) {
3208 if (flags & RD_STATE)
3209 *filpp = find_readable_file(stp->st_file);
3210 else
3211 *filpp = find_writeable_file(stp->st_file);
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04003212 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003213 }
3214 status = nfs_ok;
3215out:
3216 return status;
3217}
3218
NeilBrown4c4cd222005-07-07 17:59:27 -07003219static inline int
3220setlkflg (int type)
3221{
3222 return (type == NFS4_READW_LT || type == NFS4_READ_LT) ?
3223 RD_STATE : WR_STATE;
3224}
Linus Torvalds1da177e2005-04-16 15:20:36 -07003225
3226/*
3227 * Checks for sequence id mutating operations.
3228 */
Al Virob37ad282006-10-19 23:28:59 -07003229static __be32
Benny Halevydd453df2009-04-03 08:28:41 +03003230nfs4_preprocess_seqid_op(struct nfsd4_compound_state *cstate, u32 seqid,
3231 stateid_t *stateid, int flags,
3232 struct nfs4_stateowner **sopp,
3233 struct nfs4_stateid **stpp, struct nfsd4_lock *lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003234{
Linus Torvalds1da177e2005-04-16 15:20:36 -07003235 struct nfs4_stateid *stp;
3236 struct nfs4_stateowner *sop;
Benny Halevydd453df2009-04-03 08:28:41 +03003237 struct svc_fh *current_fh = &cstate->current_fh;
J. Bruce Fields0836f582008-01-26 19:08:12 -05003238 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003239
Benny Halevy8c10cbd2009-10-19 12:04:53 +02003240 dprintk("NFSD: %s: seqid=%d stateid = " STATEID_FMT "\n", __func__,
3241 seqid, STATEID_VAL(stateid));
NeilBrown3a4f98b2005-07-07 17:59:26 -07003242
Linus Torvalds1da177e2005-04-16 15:20:36 -07003243 *stpp = NULL;
3244 *sopp = NULL;
3245
Linus Torvalds1da177e2005-04-16 15:20:36 -07003246 if (ZERO_STATEID(stateid) || ONE_STATEID(stateid)) {
J. Bruce Fields2fdada02007-07-27 16:10:37 -04003247 dprintk("NFSD: preprocess_seqid_op: magic stateid!\n");
NeilBrown3a4f98b2005-07-07 17:59:26 -07003248 return nfserr_bad_stateid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003249 }
3250
Linus Torvalds1da177e2005-04-16 15:20:36 -07003251 if (STALE_STATEID(stateid))
NeilBrown3a4f98b2005-07-07 17:59:26 -07003252 return nfserr_stale_stateid;
Andy Adamson66689582009-04-03 08:28:45 +03003253
3254 if (nfsd4_has_session(cstate))
3255 flags |= HAS_SESSION;
3256
Linus Torvalds1da177e2005-04-16 15:20:36 -07003257 /*
3258 * We return BAD_STATEID if filehandle doesn't match stateid,
3259 * the confirmed flag is incorrecly set, or the generation
3260 * number is incorrect.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003261 */
NeilBrownf8816512005-07-07 17:59:25 -07003262 stp = find_stateid(stateid, flags);
3263 if (stp == NULL) {
3264 /*
3265 * Also, we should make sure this isn't just the result of
3266 * a replayed close:
3267 */
3268 sop = search_close_lru(stateid->si_stateownerid, flags);
J. Bruce Fields33515142010-10-02 18:42:39 -04003269 /* It's not stale; let's assume it's expired: */
NeilBrownf8816512005-07-07 17:59:25 -07003270 if (sop == NULL)
J. Bruce Fields33515142010-10-02 18:42:39 -04003271 return nfserr_expired;
NeilBrownf8816512005-07-07 17:59:25 -07003272 *sopp = sop;
3273 goto check_replay;
3274 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003275
J. Bruce Fields39325bd2007-11-26 17:06:39 -05003276 *stpp = stp;
3277 *sopp = sop = stp->st_stateowner;
3278
NeilBrown4c4cd222005-07-07 17:59:27 -07003279 if (lock) {
NeilBrown4c4cd222005-07-07 17:59:27 -07003280 clientid_t *lockclid = &lock->v.new.clientid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003281 struct nfs4_client *clp = sop->so_client;
NeilBrown4c4cd222005-07-07 17:59:27 -07003282 int lkflg = 0;
Al Virob37ad282006-10-19 23:28:59 -07003283 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003284
NeilBrown4c4cd222005-07-07 17:59:27 -07003285 lkflg = setlkflg(lock->lk_type);
3286
3287 if (lock->lk_is_new) {
J. Bruce Fields599e0a22007-07-26 17:04:54 -04003288 if (!sop->so_is_open_owner)
3289 return nfserr_bad_stateid;
Andy Adamson60adfc52009-04-03 08:28:50 +03003290 if (!(flags & HAS_SESSION) &&
3291 !same_clid(&clp->cl_clientid, lockclid))
3292 return nfserr_bad_stateid;
J. Bruce Fields599e0a22007-07-26 17:04:54 -04003293 /* stp is the open stateid */
3294 status = nfs4_check_openmode(stp, lkflg);
3295 if (status)
3296 return status;
3297 } else {
3298 /* stp is the lock stateid */
3299 status = nfs4_check_openmode(stp->st_openstp, lkflg);
3300 if (status)
3301 return status;
NeilBrown4c4cd222005-07-07 17:59:27 -07003302 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003303 }
3304
J. Bruce Fieldsf3362732008-01-26 14:58:45 -05003305 if (nfs4_check_fh(current_fh, stp)) {
J. Bruce Fields2fdada02007-07-27 16:10:37 -04003306 dprintk("NFSD: preprocess_seqid_op: fh-stateid mismatch!\n");
NeilBrown3a4f98b2005-07-07 17:59:26 -07003307 return nfserr_bad_stateid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003308 }
3309
Linus Torvalds1da177e2005-04-16 15:20:36 -07003310 /*
3311 * We now validate the seqid and stateid generation numbers.
3312 * For the moment, we ignore the possibility of
3313 * generation number wraparound.
3314 */
Andy Adamson66689582009-04-03 08:28:45 +03003315 if (!(flags & HAS_SESSION) && seqid != sop->so_seqid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003316 goto check_replay;
3317
NeilBrown3a4f98b2005-07-07 17:59:26 -07003318 if (sop->so_confirmed && flags & CONFIRM) {
J. Bruce Fields2fdada02007-07-27 16:10:37 -04003319 dprintk("NFSD: preprocess_seqid_op: expected"
NeilBrown3a4f98b2005-07-07 17:59:26 -07003320 " unconfirmed stateowner!\n");
3321 return nfserr_bad_stateid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003322 }
NeilBrown3a4f98b2005-07-07 17:59:26 -07003323 if (!sop->so_confirmed && !(flags & CONFIRM)) {
J. Bruce Fields2fdada02007-07-27 16:10:37 -04003324 dprintk("NFSD: preprocess_seqid_op: stateowner not"
NeilBrown3a4f98b2005-07-07 17:59:26 -07003325 " confirmed yet!\n");
3326 return nfserr_bad_stateid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003327 }
Andy Adamson66689582009-04-03 08:28:45 +03003328 status = check_stateid_generation(stateid, &stp->st_stateid, flags);
J. Bruce Fields0836f582008-01-26 19:08:12 -05003329 if (status)
3330 return status;
NeilBrown52fd0042005-07-07 17:59:24 -07003331 renew_client(sop->so_client);
NeilBrown3a4f98b2005-07-07 17:59:26 -07003332 return nfs_ok;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003333
Linus Torvalds1da177e2005-04-16 15:20:36 -07003334check_replay:
NeilBrownbd9aac52005-07-07 17:59:19 -07003335 if (seqid == sop->so_seqid - 1) {
Neil Brown849823c2005-09-13 01:25:36 -07003336 dprintk("NFSD: preprocess_seqid_op: retransmission?\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003337 /* indicate replay to calling function */
Al Viroa90b0612006-10-19 23:29:03 -07003338 return nfserr_replay_me;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003339 }
J. Bruce Fields2fdada02007-07-27 16:10:37 -04003340 dprintk("NFSD: preprocess_seqid_op: bad seqid (expected %d, got %d)\n",
NeilBrown3a4f98b2005-07-07 17:59:26 -07003341 sop->so_seqid, seqid);
3342 *sopp = NULL;
3343 return nfserr_bad_seqid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003344}
3345
Al Virob37ad282006-10-19 23:28:59 -07003346__be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003347nfsd4_open_confirm(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
J.Bruce Fieldsa4f1706a92006-12-13 00:35:28 -08003348 struct nfsd4_open_confirm *oc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003349{
Al Virob37ad282006-10-19 23:28:59 -07003350 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003351 struct nfs4_stateowner *sop;
3352 struct nfs4_stateid *stp;
3353
3354 dprintk("NFSD: nfsd4_open_confirm on file %.*s\n",
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003355 (int)cstate->current_fh.fh_dentry->d_name.len,
3356 cstate->current_fh.fh_dentry->d_name.name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003357
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003358 status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0);
J. Bruce Fieldsa8cddc52006-06-30 01:56:13 -07003359 if (status)
3360 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003361
3362 nfs4_lock_state();
3363
Benny Halevydd453df2009-04-03 08:28:41 +03003364 if ((status = nfs4_preprocess_seqid_op(cstate,
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003365 oc->oc_seqid, &oc->oc_req_stateid,
J. Bruce Fieldsf3362732008-01-26 14:58:45 -05003366 CONFIRM | OPEN_STATE,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003367 &oc->oc_stateowner, &stp, NULL)))
3368 goto out;
3369
3370 sop = oc->oc_stateowner;
3371 sop->so_confirmed = 1;
3372 update_stateid(&stp->st_stateid);
3373 memcpy(&oc->oc_resp_stateid, &stp->st_stateid, sizeof(stateid_t));
Benny Halevy8c10cbd2009-10-19 12:04:53 +02003374 dprintk("NFSD: %s: success, seqid=%d stateid=" STATEID_FMT "\n",
3375 __func__, oc->oc_seqid, STATEID_VAL(&stp->st_stateid));
NeilBrownc7b9a452005-06-23 22:04:30 -07003376
3377 nfsd4_create_clid_dir(sop->so_client);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003378out:
Neil Brownf2327d92005-09-13 01:25:37 -07003379 if (oc->oc_stateowner) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003380 nfs4_get_stateowner(oc->oc_stateowner);
J.Bruce Fieldsa4f1706a92006-12-13 00:35:28 -08003381 cstate->replay_owner = oc->oc_stateowner;
Neil Brownf2327d92005-09-13 01:25:37 -07003382 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003383 nfs4_unlock_state();
3384 return status;
3385}
3386
3387
3388/*
3389 * unset all bits in union bitmap (bmap) that
3390 * do not exist in share (from successful OPEN_DOWNGRADE)
3391 */
3392static void
3393reset_union_bmap_access(unsigned long access, unsigned long *bmap)
3394{
3395 int i;
3396 for (i = 1; i < 4; i++) {
3397 if ((i & access) != i)
3398 __clear_bit(i, bmap);
3399 }
3400}
3401
3402static void
3403reset_union_bmap_deny(unsigned long deny, unsigned long *bmap)
3404{
3405 int i;
3406 for (i = 0; i < 4; i++) {
3407 if ((i & deny) != i)
3408 __clear_bit(i, bmap);
3409 }
3410}
3411
Al Virob37ad282006-10-19 23:28:59 -07003412__be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003413nfsd4_open_downgrade(struct svc_rqst *rqstp,
3414 struct nfsd4_compound_state *cstate,
J.Bruce Fieldsa4f1706a92006-12-13 00:35:28 -08003415 struct nfsd4_open_downgrade *od)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003416{
Al Virob37ad282006-10-19 23:28:59 -07003417 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003418 struct nfs4_stateid *stp;
3419 unsigned int share_access;
3420
3421 dprintk("NFSD: nfsd4_open_downgrade on file %.*s\n",
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003422 (int)cstate->current_fh.fh_dentry->d_name.len,
3423 cstate->current_fh.fh_dentry->d_name.name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003424
Andy Adamsond87a8ad2009-04-03 08:28:53 +03003425 if (!access_valid(od->od_share_access, cstate->minorversion)
J. Bruce Fieldsba5a6a12006-06-30 01:56:16 -07003426 || !deny_valid(od->od_share_deny))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003427 return nfserr_inval;
3428
3429 nfs4_lock_state();
Benny Halevydd453df2009-04-03 08:28:41 +03003430 if ((status = nfs4_preprocess_seqid_op(cstate,
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003431 od->od_seqid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003432 &od->od_stateid,
J. Bruce Fieldsf3362732008-01-26 14:58:45 -05003433 OPEN_STATE,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003434 &od->od_stateowner, &stp, NULL)))
3435 goto out;
3436
3437 status = nfserr_inval;
3438 if (!test_bit(od->od_share_access, &stp->st_access_bmap)) {
3439 dprintk("NFSD:access not a subset current bitmap: 0x%lx, input access=%08x\n",
3440 stp->st_access_bmap, od->od_share_access);
3441 goto out;
3442 }
3443 if (!test_bit(od->od_share_deny, &stp->st_deny_bmap)) {
3444 dprintk("NFSD:deny not a subset current bitmap: 0x%lx, input deny=%08x\n",
3445 stp->st_deny_bmap, od->od_share_deny);
3446 goto out;
3447 }
3448 set_access(&share_access, stp->st_access_bmap);
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04003449 nfs4_file_downgrade(stp->st_file, share_access & ~od->od_share_access);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003450
3451 reset_union_bmap_access(od->od_share_access, &stp->st_access_bmap);
3452 reset_union_bmap_deny(od->od_share_deny, &stp->st_deny_bmap);
3453
3454 update_stateid(&stp->st_stateid);
3455 memcpy(&od->od_stateid, &stp->st_stateid, sizeof(stateid_t));
3456 status = nfs_ok;
3457out:
Neil Brownf2327d92005-09-13 01:25:37 -07003458 if (od->od_stateowner) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003459 nfs4_get_stateowner(od->od_stateowner);
J.Bruce Fieldsa4f1706a92006-12-13 00:35:28 -08003460 cstate->replay_owner = od->od_stateowner;
Neil Brownf2327d92005-09-13 01:25:37 -07003461 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003462 nfs4_unlock_state();
3463 return status;
3464}
3465
3466/*
3467 * nfs4_unlock_state() called after encode
3468 */
Al Virob37ad282006-10-19 23:28:59 -07003469__be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003470nfsd4_close(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
J.Bruce Fieldsa4f1706a92006-12-13 00:35:28 -08003471 struct nfsd4_close *close)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003472{
Al Virob37ad282006-10-19 23:28:59 -07003473 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003474 struct nfs4_stateid *stp;
3475
3476 dprintk("NFSD: nfsd4_close on file %.*s\n",
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003477 (int)cstate->current_fh.fh_dentry->d_name.len,
3478 cstate->current_fh.fh_dentry->d_name.name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003479
3480 nfs4_lock_state();
3481 /* check close_lru for replay */
Benny Halevydd453df2009-04-03 08:28:41 +03003482 if ((status = nfs4_preprocess_seqid_op(cstate,
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003483 close->cl_seqid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003484 &close->cl_stateid,
J. Bruce Fieldsf3362732008-01-26 14:58:45 -05003485 OPEN_STATE | CLOSE_STATE,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003486 &close->cl_stateowner, &stp, NULL)))
3487 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003488 status = nfs_ok;
3489 update_stateid(&stp->st_stateid);
3490 memcpy(&close->cl_stateid, &stp->st_stateid, sizeof(stateid_t));
3491
J. Bruce Fields04ef5952006-01-18 17:43:21 -08003492 /* release_stateid() calls nfsd_close() if needed */
J. Bruce Fields22839632009-01-11 14:27:17 -05003493 release_open_stateid(stp);
J. Bruce Fields04ef5952006-01-18 17:43:21 -08003494
3495 /* place unused nfs4_stateowners on so_close_lru list to be
3496 * released by the laundromat service after the lease period
3497 * to enable us to handle CLOSE replay
3498 */
3499 if (list_empty(&close->cl_stateowner->so_stateids))
3500 move_to_close_lru(close->cl_stateowner);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003501out:
Neil Brownf2327d92005-09-13 01:25:37 -07003502 if (close->cl_stateowner) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003503 nfs4_get_stateowner(close->cl_stateowner);
J.Bruce Fieldsa4f1706a92006-12-13 00:35:28 -08003504 cstate->replay_owner = close->cl_stateowner;
Neil Brownf2327d92005-09-13 01:25:37 -07003505 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003506 nfs4_unlock_state();
3507 return status;
3508}
3509
Al Virob37ad282006-10-19 23:28:59 -07003510__be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003511nfsd4_delegreturn(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
3512 struct nfsd4_delegreturn *dr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003513{
J. Bruce Fields203a8c82009-02-21 13:29:14 -08003514 struct nfs4_delegation *dp;
3515 stateid_t *stateid = &dr->dr_stateid;
3516 struct inode *inode;
Al Virob37ad282006-10-19 23:28:59 -07003517 __be32 status;
Andy Adamson66689582009-04-03 08:28:45 +03003518 int flags = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003519
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003520 if ((status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0)))
J. Bruce Fields203a8c82009-02-21 13:29:14 -08003521 return status;
3522 inode = cstate->current_fh.fh_dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003523
Andy Adamson66689582009-04-03 08:28:45 +03003524 if (nfsd4_has_session(cstate))
3525 flags |= HAS_SESSION;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003526 nfs4_lock_state();
J. Bruce Fields203a8c82009-02-21 13:29:14 -08003527 status = nfserr_bad_stateid;
3528 if (ZERO_STATEID(stateid) || ONE_STATEID(stateid))
3529 goto out;
3530 status = nfserr_stale_stateid;
3531 if (STALE_STATEID(stateid))
3532 goto out;
J. Bruce Fields7e0f7cf2009-02-21 13:32:28 -08003533 status = nfserr_bad_stateid;
J. Bruce Fields203a8c82009-02-21 13:29:14 -08003534 if (!is_delegation_stateid(stateid))
3535 goto out;
J. Bruce Fields33515142010-10-02 18:42:39 -04003536 status = nfserr_expired;
J. Bruce Fields203a8c82009-02-21 13:29:14 -08003537 dp = find_delegation_stateid(inode, stateid);
J. Bruce Fieldse4e83ea2010-04-22 16:21:39 -04003538 if (!dp)
J. Bruce Fields203a8c82009-02-21 13:29:14 -08003539 goto out;
Andy Adamson66689582009-04-03 08:28:45 +03003540 status = check_stateid_generation(stateid, &dp->dl_stateid, flags);
J. Bruce Fields203a8c82009-02-21 13:29:14 -08003541 if (status)
3542 goto out;
3543 renew_client(dp->dl_client);
3544
3545 unhash_delegation(dp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003546out:
J. Bruce Fields203a8c82009-02-21 13:29:14 -08003547 nfs4_unlock_state();
3548
Linus Torvalds1da177e2005-04-16 15:20:36 -07003549 return status;
3550}
3551
3552
3553/*
3554 * Lock owner state (byte-range locks)
3555 */
3556#define LOFF_OVERFLOW(start, len) ((u64)(len) > ~(u64)(start))
3557#define LOCK_HASH_BITS 8
3558#define LOCK_HASH_SIZE (1 << LOCK_HASH_BITS)
3559#define LOCK_HASH_MASK (LOCK_HASH_SIZE - 1)
3560
Benny Halevy87df4de2008-12-15 19:42:03 +02003561static inline u64
3562end_offset(u64 start, u64 len)
3563{
3564 u64 end;
3565
3566 end = start + len;
3567 return end >= start ? end: NFS4_MAX_UINT64;
3568}
3569
3570/* last octet in a range */
3571static inline u64
3572last_byte_offset(u64 start, u64 len)
3573{
3574 u64 end;
3575
3576 BUG_ON(!len);
3577 end = start + len;
3578 return end > start ? end - 1: NFS4_MAX_UINT64;
3579}
3580
Linus Torvalds1da177e2005-04-16 15:20:36 -07003581#define lockownerid_hashval(id) \
3582 ((id) & LOCK_HASH_MASK)
3583
3584static inline unsigned int
3585lock_ownerstr_hashval(struct inode *inode, u32 cl_id,
3586 struct xdr_netobj *ownername)
3587{
3588 return (file_hashval(inode) + cl_id
3589 + opaque_hashval(ownername->data, ownername->len))
3590 & LOCK_HASH_MASK;
3591}
3592
3593static struct list_head lock_ownerid_hashtbl[LOCK_HASH_SIZE];
3594static struct list_head lock_ownerstr_hashtbl[LOCK_HASH_SIZE];
3595static struct list_head lockstateid_hashtbl[STATEID_HASH_SIZE];
3596
NeilBrownfd39ca92005-06-23 22:04:03 -07003597static struct nfs4_stateid *
Linus Torvalds1da177e2005-04-16 15:20:36 -07003598find_stateid(stateid_t *stid, int flags)
3599{
Krishna Kumar9346eff2008-10-20 11:44:28 +05303600 struct nfs4_stateid *local;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003601 u32 st_id = stid->si_stateownerid;
3602 u32 f_id = stid->si_fileid;
3603 unsigned int hashval;
3604
3605 dprintk("NFSD: find_stateid flags 0x%x\n",flags);
Krishna Kumar9346eff2008-10-20 11:44:28 +05303606 if (flags & (LOCK_STATE | RD_STATE | WR_STATE)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003607 hashval = stateid_hashval(st_id, f_id);
3608 list_for_each_entry(local, &lockstateid_hashtbl[hashval], st_hash) {
3609 if ((local->st_stateid.si_stateownerid == st_id) &&
3610 (local->st_stateid.si_fileid == f_id))
3611 return local;
3612 }
3613 }
Krishna Kumar9346eff2008-10-20 11:44:28 +05303614
3615 if (flags & (OPEN_STATE | RD_STATE | WR_STATE)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003616 hashval = stateid_hashval(st_id, f_id);
3617 list_for_each_entry(local, &stateid_hashtbl[hashval], st_hash) {
3618 if ((local->st_stateid.si_stateownerid == st_id) &&
3619 (local->st_stateid.si_fileid == f_id))
3620 return local;
3621 }
Neil Brown849823c2005-09-13 01:25:36 -07003622 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003623 return NULL;
3624}
3625
3626static struct nfs4_delegation *
3627find_delegation_stateid(struct inode *ino, stateid_t *stid)
3628{
NeilBrown13cd2182005-06-23 22:03:10 -07003629 struct nfs4_file *fp;
3630 struct nfs4_delegation *dl;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003631
Benny Halevy8c10cbd2009-10-19 12:04:53 +02003632 dprintk("NFSD: %s: stateid=" STATEID_FMT "\n", __func__,
3633 STATEID_VAL(stid));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003634
Linus Torvalds1da177e2005-04-16 15:20:36 -07003635 fp = find_file(ino);
NeilBrown13cd2182005-06-23 22:03:10 -07003636 if (!fp)
3637 return NULL;
3638 dl = find_delegation_file(fp, stid);
3639 put_nfs4_file(fp);
3640 return dl;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003641}
3642
3643/*
3644 * TODO: Linux file offsets are _signed_ 64-bit quantities, which means that
3645 * we can't properly handle lock requests that go beyond the (2^63 - 1)-th
3646 * byte, because of sign extension problems. Since NFSv4 calls for 64-bit
3647 * locking, this prevents us from being completely protocol-compliant. The
3648 * real solution to this problem is to start using unsigned file offsets in
3649 * the VFS, but this is a very deep change!
3650 */
3651static inline void
3652nfs4_transform_lock_offset(struct file_lock *lock)
3653{
3654 if (lock->fl_start < 0)
3655 lock->fl_start = OFFSET_MAX;
3656 if (lock->fl_end < 0)
3657 lock->fl_end = OFFSET_MAX;
3658}
3659
NeilBrownd5b90262006-04-10 22:55:22 -07003660/* Hack!: For now, we're defining this just so we can use a pointer to it
3661 * as a unique cookie to identify our (NFSv4's) posix locks. */
Alexey Dobriyan7b021962009-09-21 17:01:12 -07003662static const struct lock_manager_operations nfsd_posix_mng_ops = {
NeilBrownd5b90262006-04-10 22:55:22 -07003663};
Linus Torvalds1da177e2005-04-16 15:20:36 -07003664
3665static inline void
3666nfs4_set_lock_denied(struct file_lock *fl, struct nfsd4_lock_denied *deny)
3667{
NeilBrownd5b90262006-04-10 22:55:22 -07003668 struct nfs4_stateowner *sop;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003669
NeilBrownd5b90262006-04-10 22:55:22 -07003670 if (fl->fl_lmops == &nfsd_posix_mng_ops) {
3671 sop = (struct nfs4_stateowner *) fl->fl_owner;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003672 kref_get(&sop->so_ref);
3673 deny->ld_sop = sop;
3674 deny->ld_clientid = sop->so_client->cl_clientid;
NeilBrownd5b90262006-04-10 22:55:22 -07003675 } else {
3676 deny->ld_sop = NULL;
3677 deny->ld_clientid.cl_boot = 0;
3678 deny->ld_clientid.cl_id = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003679 }
3680 deny->ld_start = fl->fl_start;
Benny Halevy87df4de2008-12-15 19:42:03 +02003681 deny->ld_length = NFS4_MAX_UINT64;
3682 if (fl->fl_end != NFS4_MAX_UINT64)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003683 deny->ld_length = fl->fl_end - fl->fl_start + 1;
3684 deny->ld_type = NFS4_READ_LT;
3685 if (fl->fl_type != F_RDLCK)
3686 deny->ld_type = NFS4_WRITE_LT;
3687}
3688
3689static struct nfs4_stateowner *
Linus Torvalds1da177e2005-04-16 15:20:36 -07003690find_lockstateowner_str(struct inode *inode, clientid_t *clid,
3691 struct xdr_netobj *owner)
3692{
3693 unsigned int hashval = lock_ownerstr_hashval(inode, clid->cl_id, owner);
3694 struct nfs4_stateowner *op;
3695
3696 list_for_each_entry(op, &lock_ownerstr_hashtbl[hashval], so_strhash) {
J. Bruce Fields599e0a22007-07-26 17:04:54 -04003697 if (same_owner_str(op, owner, clid))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003698 return op;
3699 }
3700 return NULL;
3701}
3702
3703/*
3704 * Alloc a lock owner structure.
3705 * Called in nfsd4_lock - therefore, OPEN and OPEN_CONFIRM (if needed) has
Lucas De Marchi25985ed2011-03-30 22:57:33 -03003706 * occurred.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003707 *
3708 * strhashval = lock_ownerstr_hashval
Linus Torvalds1da177e2005-04-16 15:20:36 -07003709 */
3710
3711static struct nfs4_stateowner *
3712alloc_init_lock_stateowner(unsigned int strhashval, struct nfs4_client *clp, struct nfs4_stateid *open_stp, struct nfsd4_lock *lock) {
3713 struct nfs4_stateowner *sop;
3714 struct nfs4_replay *rp;
3715 unsigned int idhashval;
3716
3717 if (!(sop = alloc_stateowner(&lock->lk_new_owner)))
3718 return NULL;
3719 idhashval = lockownerid_hashval(current_ownerid);
3720 INIT_LIST_HEAD(&sop->so_idhash);
3721 INIT_LIST_HEAD(&sop->so_strhash);
3722 INIT_LIST_HEAD(&sop->so_perclient);
NeilBrownea1da632005-06-23 22:04:17 -07003723 INIT_LIST_HEAD(&sop->so_stateids);
3724 INIT_LIST_HEAD(&sop->so_perstateid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003725 INIT_LIST_HEAD(&sop->so_close_lru); /* not used */
3726 sop->so_time = 0;
3727 list_add(&sop->so_idhash, &lock_ownerid_hashtbl[idhashval]);
3728 list_add(&sop->so_strhash, &lock_ownerstr_hashtbl[strhashval]);
NeilBrownea1da632005-06-23 22:04:17 -07003729 list_add(&sop->so_perstateid, &open_stp->st_lockowners);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003730 sop->so_is_open_owner = 0;
3731 sop->so_id = current_ownerid++;
3732 sop->so_client = clp;
Neil Brownb59e3c02005-09-13 01:25:38 -07003733 /* It is the openowner seqid that will be incremented in encode in the
3734 * case of new lockowners; so increment the lock seqid manually: */
3735 sop->so_seqid = lock->lk_new_lock_seqid + 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003736 sop->so_confirmed = 1;
3737 rp = &sop->so_replay;
Al Virode1ae282006-01-18 17:43:47 -08003738 rp->rp_status = nfserr_serverfault;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003739 rp->rp_buflen = 0;
3740 rp->rp_buf = rp->rp_ibuf;
3741 return sop;
3742}
3743
NeilBrownfd39ca92005-06-23 22:04:03 -07003744static struct nfs4_stateid *
Linus Torvalds1da177e2005-04-16 15:20:36 -07003745alloc_init_lock_stateid(struct nfs4_stateowner *sop, struct nfs4_file *fp, struct nfs4_stateid *open_stp)
3746{
3747 struct nfs4_stateid *stp;
3748 unsigned int hashval = stateid_hashval(sop->so_id, fp->fi_id);
3749
NeilBrown5ac049a2005-06-23 22:03:03 -07003750 stp = nfs4_alloc_stateid();
3751 if (stp == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003752 goto out;
3753 INIT_LIST_HEAD(&stp->st_hash);
3754 INIT_LIST_HEAD(&stp->st_perfile);
NeilBrownea1da632005-06-23 22:04:17 -07003755 INIT_LIST_HEAD(&stp->st_perstateowner);
3756 INIT_LIST_HEAD(&stp->st_lockowners); /* not used */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003757 list_add(&stp->st_hash, &lockstateid_hashtbl[hashval]);
NeilBrown8beefa22005-06-23 22:03:08 -07003758 list_add(&stp->st_perfile, &fp->fi_stateids);
NeilBrownea1da632005-06-23 22:04:17 -07003759 list_add(&stp->st_perstateowner, &sop->so_stateids);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003760 stp->st_stateowner = sop;
NeilBrown13cd2182005-06-23 22:03:10 -07003761 get_nfs4_file(fp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003762 stp->st_file = fp;
J. Bruce Fieldse4e83ea2010-04-22 16:21:39 -04003763 stp->st_stateid.si_boot = boot_time;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003764 stp->st_stateid.si_stateownerid = sop->so_id;
3765 stp->st_stateid.si_fileid = fp->fi_id;
3766 stp->st_stateid.si_generation = 0;
J. Bruce Fields0997b172011-03-02 18:01:35 -05003767 stp->st_access_bmap = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003768 stp->st_deny_bmap = open_stp->st_deny_bmap;
NeilBrown4c4cd222005-07-07 17:59:27 -07003769 stp->st_openstp = open_stp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003770
3771out:
3772 return stp;
3773}
3774
NeilBrownfd39ca92005-06-23 22:04:03 -07003775static int
Linus Torvalds1da177e2005-04-16 15:20:36 -07003776check_lock_length(u64 offset, u64 length)
3777{
Benny Halevy87df4de2008-12-15 19:42:03 +02003778 return ((length == 0) || ((length != NFS4_MAX_UINT64) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07003779 LOFF_OVERFLOW(offset, length)));
3780}
3781
J. Bruce Fields0997b172011-03-02 18:01:35 -05003782static void get_lock_access(struct nfs4_stateid *lock_stp, u32 access)
3783{
3784 struct nfs4_file *fp = lock_stp->st_file;
3785 int oflag = nfs4_access_to_omode(access);
3786
3787 if (test_bit(access, &lock_stp->st_access_bmap))
3788 return;
3789 nfs4_file_get_access(fp, oflag);
3790 __set_bit(access, &lock_stp->st_access_bmap);
3791}
3792
Linus Torvalds1da177e2005-04-16 15:20:36 -07003793/*
3794 * LOCK operation
3795 */
Al Virob37ad282006-10-19 23:28:59 -07003796__be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003797nfsd4_lock(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
J.Bruce Fieldsa4f1706a92006-12-13 00:35:28 -08003798 struct nfsd4_lock *lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003799{
NeilBrown3e9e3db2005-06-23 22:04:20 -07003800 struct nfs4_stateowner *open_sop = NULL;
Neil Brownb59e3c02005-09-13 01:25:38 -07003801 struct nfs4_stateowner *lock_sop = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003802 struct nfs4_stateid *lock_stp;
J. Bruce Fields7d947842010-08-20 18:09:31 -04003803 struct nfs4_file *fp;
3804 struct file *filp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003805 struct file_lock file_lock;
Andy Adamson8dc7c312006-03-20 13:44:26 -05003806 struct file_lock conflock;
Al Virob37ad282006-10-19 23:28:59 -07003807 __be32 status = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003808 unsigned int strhashval;
Al Virob8dd7b92006-10-19 23:29:01 -07003809 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003810
3811 dprintk("NFSD: nfsd4_lock: start=%Ld length=%Ld\n",
3812 (long long) lock->lk_offset,
3813 (long long) lock->lk_length);
3814
Linus Torvalds1da177e2005-04-16 15:20:36 -07003815 if (check_lock_length(lock->lk_offset, lock->lk_length))
3816 return nfserr_inval;
3817
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003818 if ((status = fh_verify(rqstp, &cstate->current_fh,
Miklos Szeredi8837abc2008-06-16 13:20:29 +02003819 S_IFREG, NFSD_MAY_LOCK))) {
Andy Adamsona6f6ef22006-01-18 17:43:17 -08003820 dprintk("NFSD: nfsd4_lock: permission denied!\n");
3821 return status;
3822 }
3823
Linus Torvalds1da177e2005-04-16 15:20:36 -07003824 nfs4_lock_state();
3825
3826 if (lock->lk_is_new) {
NeilBrown893f8772005-07-07 17:59:17 -07003827 /*
3828 * Client indicates that this is a new lockowner.
3829 * Use open owner and open stateid to create lock owner and
3830 * lock stateid.
3831 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003832 struct nfs4_stateid *open_stp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003833
3834 status = nfserr_stale_clientid;
Andy Adamson60adfc52009-04-03 08:28:50 +03003835 if (!nfsd4_has_session(cstate) &&
3836 STALE_CLIENTID(&lock->lk_new_clientid))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003837 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003838
Linus Torvalds1da177e2005-04-16 15:20:36 -07003839 /* validate and update open stateid and open seqid */
Benny Halevydd453df2009-04-03 08:28:41 +03003840 status = nfs4_preprocess_seqid_op(cstate,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003841 lock->lk_new_open_seqid,
3842 &lock->lk_new_open_stateid,
J. Bruce Fieldsf3362732008-01-26 14:58:45 -05003843 OPEN_STATE,
J. Bruce Fields3a655882006-01-18 17:43:19 -08003844 &lock->lk_replay_owner, &open_stp,
Neil Brownb59e3c02005-09-13 01:25:38 -07003845 lock);
NeilBrown37515172005-07-07 17:59:16 -07003846 if (status)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003847 goto out;
J. Bruce Fields3a655882006-01-18 17:43:19 -08003848 open_sop = lock->lk_replay_owner;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003849 /* create lockowner and lock stateid */
3850 fp = open_stp->st_file;
3851 strhashval = lock_ownerstr_hashval(fp->fi_inode,
3852 open_sop->so_client->cl_clientid.cl_id,
3853 &lock->v.new.owner);
NeilBrown3e9e3db2005-06-23 22:04:20 -07003854 /* XXX: Do we need to check for duplicate stateowners on
3855 * the same file, or should they just be allowed (and
3856 * create new stateids)? */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003857 status = nfserr_resource;
Neil Brownb59e3c02005-09-13 01:25:38 -07003858 lock_sop = alloc_init_lock_stateowner(strhashval,
3859 open_sop->so_client, open_stp, lock);
3860 if (lock_sop == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003861 goto out;
Neil Brownb59e3c02005-09-13 01:25:38 -07003862 lock_stp = alloc_init_lock_stateid(lock_sop, fp, open_stp);
J. Bruce Fields8a280512006-01-18 17:43:18 -08003863 if (lock_stp == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003864 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003865 } else {
3866 /* lock (lock owner + lock stateid) already exists */
Benny Halevydd453df2009-04-03 08:28:41 +03003867 status = nfs4_preprocess_seqid_op(cstate,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003868 lock->lk_old_lock_seqid,
3869 &lock->lk_old_lock_stateid,
J. Bruce Fieldsf3362732008-01-26 14:58:45 -05003870 LOCK_STATE,
J. Bruce Fields3a655882006-01-18 17:43:19 -08003871 &lock->lk_replay_owner, &lock_stp, lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003872 if (status)
3873 goto out;
J. Bruce Fields3a655882006-01-18 17:43:19 -08003874 lock_sop = lock->lk_replay_owner;
J. Bruce Fields7d947842010-08-20 18:09:31 -04003875 fp = lock_stp->st_file;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003876 }
J. Bruce Fields3a655882006-01-18 17:43:19 -08003877 /* lock->lk_replay_owner and lock_stp have been created or found */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003878
NeilBrown0dd395d2005-07-07 17:59:15 -07003879 status = nfserr_grace;
J. Bruce Fieldsaf558e32007-09-06 12:34:25 -04003880 if (locks_in_grace() && !lock->lk_reclaim)
NeilBrown0dd395d2005-07-07 17:59:15 -07003881 goto out;
3882 status = nfserr_no_grace;
J. Bruce Fieldsaf558e32007-09-06 12:34:25 -04003883 if (!locks_in_grace() && lock->lk_reclaim)
NeilBrown0dd395d2005-07-07 17:59:15 -07003884 goto out;
3885
Linus Torvalds1da177e2005-04-16 15:20:36 -07003886 locks_init_lock(&file_lock);
3887 switch (lock->lk_type) {
3888 case NFS4_READ_LT:
3889 case NFS4_READW_LT:
J. Bruce Fields0997b172011-03-02 18:01:35 -05003890 filp = find_readable_file(lock_stp->st_file);
3891 if (filp)
3892 get_lock_access(lock_stp, NFS4_SHARE_ACCESS_READ);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003893 file_lock.fl_type = F_RDLCK;
J. Bruce Fields529d7b22011-03-02 23:48:33 -05003894 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003895 case NFS4_WRITE_LT:
3896 case NFS4_WRITEW_LT:
J. Bruce Fields0997b172011-03-02 18:01:35 -05003897 filp = find_writeable_file(lock_stp->st_file);
3898 if (filp)
3899 get_lock_access(lock_stp, NFS4_SHARE_ACCESS_WRITE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003900 file_lock.fl_type = F_WRLCK;
J. Bruce Fields529d7b22011-03-02 23:48:33 -05003901 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003902 default:
3903 status = nfserr_inval;
3904 goto out;
3905 }
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04003906 if (!filp) {
3907 status = nfserr_openmode;
3908 goto out;
3909 }
Neil Brownb59e3c02005-09-13 01:25:38 -07003910 file_lock.fl_owner = (fl_owner_t)lock_sop;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003911 file_lock.fl_pid = current->tgid;
3912 file_lock.fl_file = filp;
3913 file_lock.fl_flags = FL_POSIX;
NeilBrownd5b90262006-04-10 22:55:22 -07003914 file_lock.fl_lmops = &nfsd_posix_mng_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003915
3916 file_lock.fl_start = lock->lk_offset;
Benny Halevy87df4de2008-12-15 19:42:03 +02003917 file_lock.fl_end = last_byte_offset(lock->lk_offset, lock->lk_length);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003918 nfs4_transform_lock_offset(&file_lock);
3919
3920 /*
3921 * Try to lock the file in the VFS.
3922 * Note: locks.c uses the BKL to protect the inode's lock list.
3923 */
3924
J. Bruce Fields529d7b22011-03-02 23:48:33 -05003925 err = vfs_lock_file(filp, F_SETLK, &file_lock, &conflock);
Al Virob8dd7b92006-10-19 23:29:01 -07003926 switch (-err) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003927 case 0: /* success! */
3928 update_stateid(&lock_stp->st_stateid);
3929 memcpy(&lock->lk_resp_stateid, &lock_stp->st_stateid,
3930 sizeof(stateid_t));
Al Virob8dd7b92006-10-19 23:29:01 -07003931 status = 0;
Andy Adamsoneb76b3f2006-03-26 01:37:26 -08003932 break;
3933 case (EAGAIN): /* conflock holds conflicting lock */
3934 status = nfserr_denied;
3935 dprintk("NFSD: nfsd4_lock: conflicting lock found!\n");
3936 nfs4_set_lock_denied(&conflock, &lock->lk_denied);
3937 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003938 case (EDEADLK):
3939 status = nfserr_deadlock;
Andy Adamsoneb76b3f2006-03-26 01:37:26 -08003940 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003941 default:
Marc Eshelfd85b812006-11-28 16:26:41 -05003942 dprintk("NFSD: nfsd4_lock: vfs_lock_file() failed! status %d\n",err);
Andy Adamsoneb76b3f2006-03-26 01:37:26 -08003943 status = nfserr_resource;
3944 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003945 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003946out:
J. Bruce Fields8a280512006-01-18 17:43:18 -08003947 if (status && lock->lk_is_new && lock_sop)
J. Bruce Fieldsf044ff82009-01-11 15:24:04 -05003948 release_lockowner(lock_sop);
J. Bruce Fields3a655882006-01-18 17:43:19 -08003949 if (lock->lk_replay_owner) {
3950 nfs4_get_stateowner(lock->lk_replay_owner);
J.Bruce Fieldsa4f1706a92006-12-13 00:35:28 -08003951 cstate->replay_owner = lock->lk_replay_owner;
Neil Brownf2327d92005-09-13 01:25:37 -07003952 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003953 nfs4_unlock_state();
3954 return status;
3955}
3956
3957/*
J. Bruce Fields55ef1272008-12-20 11:58:38 -08003958 * The NFSv4 spec allows a client to do a LOCKT without holding an OPEN,
3959 * so we do a temporary open here just to get an open file to pass to
3960 * vfs_test_lock. (Arguably perhaps test_lock should be done with an
3961 * inode operation.)
3962 */
3963static int nfsd_test_lock(struct svc_rqst *rqstp, struct svc_fh *fhp, struct file_lock *lock)
3964{
3965 struct file *file;
3966 int err;
3967
3968 err = nfsd_open(rqstp, fhp, S_IFREG, NFSD_MAY_READ, &file);
3969 if (err)
3970 return err;
3971 err = vfs_test_lock(file, lock);
3972 nfsd_close(file);
3973 return err;
3974}
3975
3976/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07003977 * LOCKT operation
3978 */
Al Virob37ad282006-10-19 23:28:59 -07003979__be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003980nfsd4_lockt(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
3981 struct nfsd4_lockt *lockt)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003982{
3983 struct inode *inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003984 struct file_lock file_lock;
Marc Eshelfd85b812006-11-28 16:26:41 -05003985 int error;
Al Virob37ad282006-10-19 23:28:59 -07003986 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003987
J. Bruce Fieldsaf558e32007-09-06 12:34:25 -04003988 if (locks_in_grace())
Linus Torvalds1da177e2005-04-16 15:20:36 -07003989 return nfserr_grace;
3990
3991 if (check_lock_length(lockt->lt_offset, lockt->lt_length))
3992 return nfserr_inval;
3993
3994 lockt->lt_stateowner = NULL;
3995 nfs4_lock_state();
3996
3997 status = nfserr_stale_clientid;
Andy Adamson60adfc52009-04-03 08:28:50 +03003998 if (!nfsd4_has_session(cstate) && STALE_CLIENTID(&lockt->lt_clientid))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003999 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004000
J.Bruce Fieldsca364312006-12-13 00:35:27 -08004001 if ((status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0))) {
Neil Brown849823c2005-09-13 01:25:36 -07004002 dprintk("NFSD: nfsd4_lockt: fh_verify() failed!\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07004003 if (status == nfserr_symlink)
4004 status = nfserr_inval;
4005 goto out;
4006 }
4007
J.Bruce Fieldsca364312006-12-13 00:35:27 -08004008 inode = cstate->current_fh.fh_dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004009 locks_init_lock(&file_lock);
4010 switch (lockt->lt_type) {
4011 case NFS4_READ_LT:
4012 case NFS4_READW_LT:
4013 file_lock.fl_type = F_RDLCK;
4014 break;
4015 case NFS4_WRITE_LT:
4016 case NFS4_WRITEW_LT:
4017 file_lock.fl_type = F_WRLCK;
4018 break;
4019 default:
J. Bruce Fields2fdada02007-07-27 16:10:37 -04004020 dprintk("NFSD: nfs4_lockt: bad lock type!\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07004021 status = nfserr_inval;
4022 goto out;
4023 }
4024
4025 lockt->lt_stateowner = find_lockstateowner_str(inode,
4026 &lockt->lt_clientid, &lockt->lt_owner);
4027 if (lockt->lt_stateowner)
4028 file_lock.fl_owner = (fl_owner_t)lockt->lt_stateowner;
4029 file_lock.fl_pid = current->tgid;
4030 file_lock.fl_flags = FL_POSIX;
4031
4032 file_lock.fl_start = lockt->lt_offset;
Benny Halevy87df4de2008-12-15 19:42:03 +02004033 file_lock.fl_end = last_byte_offset(lockt->lt_offset, lockt->lt_length);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004034
4035 nfs4_transform_lock_offset(&file_lock);
4036
Linus Torvalds1da177e2005-04-16 15:20:36 -07004037 status = nfs_ok;
J. Bruce Fields55ef1272008-12-20 11:58:38 -08004038 error = nfsd_test_lock(rqstp, &cstate->current_fh, &file_lock);
Marc Eshelfd85b812006-11-28 16:26:41 -05004039 if (error) {
4040 status = nfserrno(error);
4041 goto out;
4042 }
Marc Eshel9d6a8c52007-02-21 00:55:18 -05004043 if (file_lock.fl_type != F_UNLCK) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004044 status = nfserr_denied;
Marc Eshel9d6a8c52007-02-21 00:55:18 -05004045 nfs4_set_lock_denied(&file_lock, &lockt->lt_denied);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004046 }
4047out:
4048 nfs4_unlock_state();
4049 return status;
4050}
4051
Al Virob37ad282006-10-19 23:28:59 -07004052__be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -08004053nfsd4_locku(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
J.Bruce Fieldsa4f1706a92006-12-13 00:35:28 -08004054 struct nfsd4_locku *locku)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004055{
4056 struct nfs4_stateid *stp;
4057 struct file *filp = NULL;
4058 struct file_lock file_lock;
Al Virob37ad282006-10-19 23:28:59 -07004059 __be32 status;
Al Virob8dd7b92006-10-19 23:29:01 -07004060 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004061
4062 dprintk("NFSD: nfsd4_locku: start=%Ld length=%Ld\n",
4063 (long long) locku->lu_offset,
4064 (long long) locku->lu_length);
4065
4066 if (check_lock_length(locku->lu_offset, locku->lu_length))
4067 return nfserr_inval;
4068
4069 nfs4_lock_state();
4070
Benny Halevydd453df2009-04-03 08:28:41 +03004071 if ((status = nfs4_preprocess_seqid_op(cstate,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004072 locku->lu_seqid,
4073 &locku->lu_stateid,
J. Bruce Fieldsf3362732008-01-26 14:58:45 -05004074 LOCK_STATE,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004075 &locku->lu_stateowner, &stp, NULL)))
4076 goto out;
4077
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04004078 filp = find_any_file(stp->st_file);
4079 if (!filp) {
4080 status = nfserr_lock_range;
4081 goto out;
4082 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004083 BUG_ON(!filp);
4084 locks_init_lock(&file_lock);
4085 file_lock.fl_type = F_UNLCK;
4086 file_lock.fl_owner = (fl_owner_t) locku->lu_stateowner;
4087 file_lock.fl_pid = current->tgid;
4088 file_lock.fl_file = filp;
4089 file_lock.fl_flags = FL_POSIX;
NeilBrownd5b90262006-04-10 22:55:22 -07004090 file_lock.fl_lmops = &nfsd_posix_mng_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004091 file_lock.fl_start = locku->lu_offset;
4092
Benny Halevy87df4de2008-12-15 19:42:03 +02004093 file_lock.fl_end = last_byte_offset(locku->lu_offset, locku->lu_length);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004094 nfs4_transform_lock_offset(&file_lock);
4095
4096 /*
4097 * Try to unlock the file in the VFS.
4098 */
Marc Eshelfd85b812006-11-28 16:26:41 -05004099 err = vfs_lock_file(filp, F_SETLK, &file_lock, NULL);
Al Virob8dd7b92006-10-19 23:29:01 -07004100 if (err) {
Marc Eshelfd85b812006-11-28 16:26:41 -05004101 dprintk("NFSD: nfs4_locku: vfs_lock_file failed!\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07004102 goto out_nfserr;
4103 }
4104 /*
4105 * OK, unlock succeeded; the only thing left to do is update the stateid.
4106 */
4107 update_stateid(&stp->st_stateid);
4108 memcpy(&locku->lu_stateid, &stp->st_stateid, sizeof(stateid_t));
4109
4110out:
Neil Brownf2327d92005-09-13 01:25:37 -07004111 if (locku->lu_stateowner) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004112 nfs4_get_stateowner(locku->lu_stateowner);
J.Bruce Fieldsa4f1706a92006-12-13 00:35:28 -08004113 cstate->replay_owner = locku->lu_stateowner;
Neil Brownf2327d92005-09-13 01:25:37 -07004114 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004115 nfs4_unlock_state();
4116 return status;
4117
4118out_nfserr:
Al Virob8dd7b92006-10-19 23:29:01 -07004119 status = nfserrno(err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004120 goto out;
4121}
4122
4123/*
4124 * returns
4125 * 1: locks held by lockowner
4126 * 0: no locks held by lockowner
4127 */
4128static int
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04004129check_for_locks(struct nfs4_file *filp, struct nfs4_stateowner *lowner)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004130{
4131 struct file_lock **flpp;
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04004132 struct inode *inode = filp->fi_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004133 int status = 0;
4134
Arnd Bergmannb89f4322010-09-18 15:09:31 +02004135 lock_flocks();
Linus Torvalds1da177e2005-04-16 15:20:36 -07004136 for (flpp = &inode->i_flock; *flpp != NULL; flpp = &(*flpp)->fl_next) {
J. Bruce Fields796dadf2006-01-18 17:43:22 -08004137 if ((*flpp)->fl_owner == (fl_owner_t)lowner) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004138 status = 1;
4139 goto out;
J. Bruce Fields796dadf2006-01-18 17:43:22 -08004140 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004141 }
4142out:
Arnd Bergmannb89f4322010-09-18 15:09:31 +02004143 unlock_flocks();
Linus Torvalds1da177e2005-04-16 15:20:36 -07004144 return status;
4145}
4146
Al Virob37ad282006-10-19 23:28:59 -07004147__be32
J.Bruce Fieldsb5914802006-12-13 00:35:38 -08004148nfsd4_release_lockowner(struct svc_rqst *rqstp,
4149 struct nfsd4_compound_state *cstate,
4150 struct nfsd4_release_lockowner *rlockowner)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004151{
4152 clientid_t *clid = &rlockowner->rl_clientid;
NeilBrown3e9e3db2005-06-23 22:04:20 -07004153 struct nfs4_stateowner *sop;
4154 struct nfs4_stateid *stp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004155 struct xdr_netobj *owner = &rlockowner->rl_owner;
NeilBrown3e9e3db2005-06-23 22:04:20 -07004156 struct list_head matches;
4157 int i;
Al Virob37ad282006-10-19 23:28:59 -07004158 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004159
4160 dprintk("nfsd4_release_lockowner clientid: (%08x/%08x):\n",
4161 clid->cl_boot, clid->cl_id);
4162
4163 /* XXX check for lease expiration */
4164
4165 status = nfserr_stale_clientid;
Neil Brown849823c2005-09-13 01:25:36 -07004166 if (STALE_CLIENTID(clid))
Linus Torvalds1da177e2005-04-16 15:20:36 -07004167 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004168
4169 nfs4_lock_state();
4170
NeilBrown3e9e3db2005-06-23 22:04:20 -07004171 status = nfserr_locks_held;
4172 /* XXX: we're doing a linear search through all the lockowners.
4173 * Yipes! For now we'll just hope clients aren't really using
4174 * release_lockowner much, but eventually we have to fix these
4175 * data structures. */
4176 INIT_LIST_HEAD(&matches);
4177 for (i = 0; i < LOCK_HASH_SIZE; i++) {
4178 list_for_each_entry(sop, &lock_ownerid_hashtbl[i], so_idhash) {
J. Bruce Fields599e0a22007-07-26 17:04:54 -04004179 if (!same_owner_str(sop, owner, clid))
NeilBrown3e9e3db2005-06-23 22:04:20 -07004180 continue;
4181 list_for_each_entry(stp, &sop->so_stateids,
4182 st_perstateowner) {
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04004183 if (check_for_locks(stp->st_file, sop))
NeilBrown3e9e3db2005-06-23 22:04:20 -07004184 goto out;
4185 /* Note: so_perclient unused for lockowners,
4186 * so it's OK to fool with here. */
4187 list_add(&sop->so_perclient, &matches);
4188 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004189 }
NeilBrown3e9e3db2005-06-23 22:04:20 -07004190 }
4191 /* Clients probably won't expect us to return with some (but not all)
4192 * of the lockowner state released; so don't release any until all
4193 * have been checked. */
4194 status = nfs_ok;
NeilBrown0fa822e2005-07-07 17:59:14 -07004195 while (!list_empty(&matches)) {
4196 sop = list_entry(matches.next, struct nfs4_stateowner,
4197 so_perclient);
4198 /* unhash_stateowner deletes so_perclient only
4199 * for openowners. */
4200 list_del(&sop->so_perclient);
J. Bruce Fieldsf044ff82009-01-11 15:24:04 -05004201 release_lockowner(sop);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004202 }
4203out:
4204 nfs4_unlock_state();
4205 return status;
4206}
4207
4208static inline struct nfs4_client_reclaim *
NeilBrowna55370a2005-06-23 22:03:52 -07004209alloc_reclaim(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004210{
NeilBrowna55370a2005-06-23 22:03:52 -07004211 return kmalloc(sizeof(struct nfs4_client_reclaim), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004212}
4213
NeilBrownc7b9a452005-06-23 22:04:30 -07004214int
Andy Adamsona1bcecd2009-04-03 08:28:05 +03004215nfs4_has_reclaimed_state(const char *name, bool use_exchange_id)
NeilBrownc7b9a452005-06-23 22:04:30 -07004216{
4217 unsigned int strhashval = clientstr_hashval(name);
4218 struct nfs4_client *clp;
4219
J. Bruce Fieldse203d502010-11-24 17:30:54 -05004220 clp = find_confirmed_client_by_str(name, strhashval);
NeilBrownc7b9a452005-06-23 22:04:30 -07004221 return clp ? 1 : 0;
4222}
4223
Linus Torvalds1da177e2005-04-16 15:20:36 -07004224/*
4225 * failure => all reset bets are off, nfserr_no_grace...
4226 */
NeilBrown190e4fb2005-06-23 22:04:25 -07004227int
4228nfs4_client_to_reclaim(const char *name)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004229{
4230 unsigned int strhashval;
4231 struct nfs4_client_reclaim *crp = NULL;
4232
NeilBrowna55370a2005-06-23 22:03:52 -07004233 dprintk("NFSD nfs4_client_to_reclaim NAME: %.*s\n", HEXDIR_LEN, name);
4234 crp = alloc_reclaim();
Linus Torvalds1da177e2005-04-16 15:20:36 -07004235 if (!crp)
4236 return 0;
NeilBrowna55370a2005-06-23 22:03:52 -07004237 strhashval = clientstr_hashval(name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004238 INIT_LIST_HEAD(&crp->cr_strhash);
4239 list_add(&crp->cr_strhash, &reclaim_str_hashtbl[strhashval]);
NeilBrowna55370a2005-06-23 22:03:52 -07004240 memcpy(crp->cr_recdir, name, HEXDIR_LEN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004241 reclaim_str_hashtbl_size++;
4242 return 1;
4243}
4244
4245static void
4246nfs4_release_reclaim(void)
4247{
4248 struct nfs4_client_reclaim *crp = NULL;
4249 int i;
4250
Linus Torvalds1da177e2005-04-16 15:20:36 -07004251 for (i = 0; i < CLIENT_HASH_SIZE; i++) {
4252 while (!list_empty(&reclaim_str_hashtbl[i])) {
4253 crp = list_entry(reclaim_str_hashtbl[i].next,
4254 struct nfs4_client_reclaim, cr_strhash);
4255 list_del(&crp->cr_strhash);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004256 kfree(crp);
4257 reclaim_str_hashtbl_size--;
4258 }
4259 }
4260 BUG_ON(reclaim_str_hashtbl_size);
4261}
4262
4263/*
4264 * called from OPEN, CLAIM_PREVIOUS with a new clientid. */
NeilBrownfd39ca92005-06-23 22:04:03 -07004265static struct nfs4_client_reclaim *
Linus Torvalds1da177e2005-04-16 15:20:36 -07004266nfs4_find_reclaim_client(clientid_t *clid)
4267{
4268 unsigned int strhashval;
4269 struct nfs4_client *clp;
4270 struct nfs4_client_reclaim *crp = NULL;
4271
4272
4273 /* find clientid in conf_id_hashtbl */
4274 clp = find_confirmed_client(clid);
4275 if (clp == NULL)
4276 return NULL;
4277
NeilBrowna55370a2005-06-23 22:03:52 -07004278 dprintk("NFSD: nfs4_find_reclaim_client for %.*s with recdir %s\n",
4279 clp->cl_name.len, clp->cl_name.data,
4280 clp->cl_recdir);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004281
4282 /* find clp->cl_name in reclaim_str_hashtbl */
NeilBrowna55370a2005-06-23 22:03:52 -07004283 strhashval = clientstr_hashval(clp->cl_recdir);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004284 list_for_each_entry(crp, &reclaim_str_hashtbl[strhashval], cr_strhash) {
NeilBrowna55370a2005-06-23 22:03:52 -07004285 if (same_name(crp->cr_recdir, clp->cl_recdir)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004286 return crp;
4287 }
4288 }
4289 return NULL;
4290}
4291
4292/*
4293* Called from OPEN. Look for clientid in reclaim list.
4294*/
Al Virob37ad282006-10-19 23:28:59 -07004295__be32
Linus Torvalds1da177e2005-04-16 15:20:36 -07004296nfs4_check_open_reclaim(clientid_t *clid)
4297{
NeilBrowndfc83562005-06-23 22:03:16 -07004298 return nfs4_find_reclaim_client(clid) ? nfs_ok : nfserr_reclaim_bad;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004299}
4300
NeilBrownac4d8ff22005-06-23 22:03:30 -07004301/* initialization to perform at module load time: */
Linus Torvalds1da177e2005-04-16 15:20:36 -07004302
J. Bruce Fieldse8ff2a82007-08-01 15:30:59 -04004303int
NeilBrownac4d8ff22005-06-23 22:03:30 -07004304nfs4_state_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004305{
J. Bruce Fieldse8ff2a82007-08-01 15:30:59 -04004306 int i, status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004307
J. Bruce Fieldse8ff2a82007-08-01 15:30:59 -04004308 status = nfsd4_init_slabs();
4309 if (status)
4310 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004311 for (i = 0; i < CLIENT_HASH_SIZE; i++) {
4312 INIT_LIST_HEAD(&conf_id_hashtbl[i]);
4313 INIT_LIST_HEAD(&conf_str_hashtbl[i]);
4314 INIT_LIST_HEAD(&unconf_str_hashtbl[i]);
4315 INIT_LIST_HEAD(&unconf_id_hashtbl[i]);
Wang Chen02cb2852009-04-24 15:41:57 +08004316 INIT_LIST_HEAD(&reclaim_str_hashtbl[i]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004317 }
Marc Eshel5282fd72009-04-03 08:27:52 +03004318 for (i = 0; i < SESSION_HASH_SIZE; i++)
4319 INIT_LIST_HEAD(&sessionid_hashtbl[i]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004320 for (i = 0; i < FILE_HASH_SIZE; i++) {
4321 INIT_LIST_HEAD(&file_hashtbl[i]);
4322 }
4323 for (i = 0; i < OWNER_HASH_SIZE; i++) {
4324 INIT_LIST_HEAD(&ownerstr_hashtbl[i]);
4325 INIT_LIST_HEAD(&ownerid_hashtbl[i]);
4326 }
4327 for (i = 0; i < STATEID_HASH_SIZE; i++) {
4328 INIT_LIST_HEAD(&stateid_hashtbl[i]);
4329 INIT_LIST_HEAD(&lockstateid_hashtbl[i]);
4330 }
4331 for (i = 0; i < LOCK_HASH_SIZE; i++) {
4332 INIT_LIST_HEAD(&lock_ownerid_hashtbl[i]);
4333 INIT_LIST_HEAD(&lock_ownerstr_hashtbl[i]);
4334 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004335 memset(&onestateid, ~0, sizeof(stateid_t));
Linus Torvalds1da177e2005-04-16 15:20:36 -07004336 INIT_LIST_HEAD(&close_lru);
4337 INIT_LIST_HEAD(&client_lru);
4338 INIT_LIST_HEAD(&del_recall_lru);
NeilBrownac4d8ff22005-06-23 22:03:30 -07004339 reclaim_str_hashtbl_size = 0;
J. Bruce Fieldse8ff2a82007-08-01 15:30:59 -04004340 return 0;
NeilBrownac4d8ff22005-06-23 22:03:30 -07004341}
4342
NeilBrown190e4fb2005-06-23 22:04:25 -07004343static void
4344nfsd4_load_reboot_recovery_data(void)
4345{
4346 int status;
4347
NeilBrown0964a3d2005-06-23 22:04:32 -07004348 nfs4_lock_state();
4349 nfsd4_init_recdir(user_recovery_dirname);
NeilBrown190e4fb2005-06-23 22:04:25 -07004350 status = nfsd4_recdir_load();
NeilBrown0964a3d2005-06-23 22:04:32 -07004351 nfs4_unlock_state();
NeilBrown190e4fb2005-06-23 22:04:25 -07004352 if (status)
4353 printk("NFSD: Failure reading reboot recovery data\n");
4354}
4355
Meelap Shahc2f1a552007-07-17 04:04:39 -07004356/*
4357 * Since the lifetime of a delegation isn't limited to that of an open, a
4358 * client may quite reasonably hang on to a delegation as long as it has
4359 * the inode cached. This becomes an obvious problem the first time a
4360 * client's inode cache approaches the size of the server's total memory.
4361 *
4362 * For now we avoid this problem by imposing a hard limit on the number
4363 * of delegations, which varies according to the server's memory size.
4364 */
4365static void
4366set_max_delegations(void)
4367{
4368 /*
4369 * Allow at most 4 delegations per megabyte of RAM. Quick
4370 * estimates suggest that in the worst case (where every delegation
4371 * is for a different inode), a delegation could take about 1.5K,
4372 * giving a worst case usage of about 6% of memory.
4373 */
4374 max_delegations = nr_free_buffer_pages() >> (20 - 2 - PAGE_SHIFT);
4375}
4376
NeilBrownac4d8ff22005-06-23 22:03:30 -07004377/* initialization to perform when the nfsd service is started: */
4378
J. Bruce Fields29ab23c2009-09-15 15:56:50 -04004379static int
NeilBrownac4d8ff22005-06-23 22:03:30 -07004380__nfs4_state_start(void)
4381{
J. Bruce Fieldsb5a1a812010-03-03 14:52:55 -05004382 int ret;
4383
Linus Torvalds1da177e2005-04-16 15:20:36 -07004384 boot_time = get_seconds();
J. Bruce Fieldsaf558e32007-09-06 12:34:25 -04004385 locks_start_grace(&nfsd4_manager);
Marc Eshel9a8db972007-07-17 04:04:35 -07004386 printk(KERN_INFO "NFSD: starting %ld-second grace period\n",
J. Bruce Fieldse46b4982010-03-01 19:21:21 -05004387 nfsd4_grace);
J. Bruce Fieldsb5a1a812010-03-03 14:52:55 -05004388 ret = set_callback_cred();
4389 if (ret)
4390 return -ENOMEM;
NeilBrown58da2822005-06-23 22:03:19 -07004391 laundry_wq = create_singlethread_workqueue("nfsd4");
J. Bruce Fields29ab23c2009-09-15 15:56:50 -04004392 if (laundry_wq == NULL)
4393 return -ENOMEM;
J. Bruce Fieldsb5a1a812010-03-03 14:52:55 -05004394 ret = nfsd4_create_callback_queue();
4395 if (ret)
4396 goto out_free_laundry;
J. Bruce Fieldse46b4982010-03-01 19:21:21 -05004397 queue_delayed_work(laundry_wq, &laundromat_work, nfsd4_grace * HZ);
Meelap Shahc2f1a552007-07-17 04:04:39 -07004398 set_max_delegations();
J. Bruce Fieldsb5a1a812010-03-03 14:52:55 -05004399 return 0;
4400out_free_laundry:
4401 destroy_workqueue(laundry_wq);
4402 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004403}
4404
J. Bruce Fields29ab23c2009-09-15 15:56:50 -04004405int
NeilBrown76a35502005-06-23 22:03:26 -07004406nfs4_state_start(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004407{
NeilBrown190e4fb2005-06-23 22:04:25 -07004408 nfsd4_load_reboot_recovery_data();
Jeff Layton4ad9a342010-07-19 16:50:04 -04004409 return __nfs4_state_start();
Linus Torvalds1da177e2005-04-16 15:20:36 -07004410}
4411
Linus Torvalds1da177e2005-04-16 15:20:36 -07004412static void
4413__nfs4_state_shutdown(void)
4414{
4415 int i;
4416 struct nfs4_client *clp = NULL;
4417 struct nfs4_delegation *dp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004418 struct list_head *pos, *next, reaplist;
4419
Linus Torvalds1da177e2005-04-16 15:20:36 -07004420 for (i = 0; i < CLIENT_HASH_SIZE; i++) {
4421 while (!list_empty(&conf_id_hashtbl[i])) {
4422 clp = list_entry(conf_id_hashtbl[i].next, struct nfs4_client, cl_idhash);
4423 expire_client(clp);
4424 }
4425 while (!list_empty(&unconf_str_hashtbl[i])) {
4426 clp = list_entry(unconf_str_hashtbl[i].next, struct nfs4_client, cl_strhash);
4427 expire_client(clp);
4428 }
4429 }
4430 INIT_LIST_HEAD(&reaplist);
4431 spin_lock(&recall_lock);
4432 list_for_each_safe(pos, next, &del_recall_lru) {
4433 dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
4434 list_move(&dp->dl_recall_lru, &reaplist);
4435 }
4436 spin_unlock(&recall_lock);
4437 list_for_each_safe(pos, next, &reaplist) {
4438 dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
4439 list_del_init(&dp->dl_recall_lru);
4440 unhash_delegation(dp);
4441 }
4442
NeilBrown190e4fb2005-06-23 22:04:25 -07004443 nfsd4_shutdown_recdir();
Linus Torvalds1da177e2005-04-16 15:20:36 -07004444}
4445
4446void
4447nfs4_state_shutdown(void)
4448{
Tejun Heoafe2c512010-12-14 16:21:17 +01004449 cancel_delayed_work_sync(&laundromat_work);
NeilBrown5e8d5c22006-04-10 22:55:37 -07004450 destroy_workqueue(laundry_wq);
J. Bruce Fields2c5e7612008-11-20 14:36:17 -06004451 locks_end_grace(&nfsd4_manager);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004452 nfs4_lock_state();
4453 nfs4_release_reclaim();
4454 __nfs4_state_shutdown();
Linus Torvalds1da177e2005-04-16 15:20:36 -07004455 nfs4_unlock_state();
J. Bruce Fieldsc3935e32010-06-04 16:42:08 -04004456 nfsd4_destroy_callback_queue();
Linus Torvalds1da177e2005-04-16 15:20:36 -07004457}
4458
Jeff Layton3dd98a32008-06-10 08:40:36 -04004459/*
4460 * user_recovery_dirname is protected by the nfsd_mutex since it's only
4461 * accessed when nfsd is starting.
4462 */
NeilBrown0964a3d2005-06-23 22:04:32 -07004463static void
4464nfs4_set_recdir(char *recdir)
4465{
NeilBrown0964a3d2005-06-23 22:04:32 -07004466 strcpy(user_recovery_dirname, recdir);
NeilBrown0964a3d2005-06-23 22:04:32 -07004467}
4468
4469/*
4470 * Change the NFSv4 recovery directory to recdir.
4471 */
4472int
4473nfs4_reset_recoverydir(char *recdir)
4474{
4475 int status;
Al Viroa63bb992008-08-02 01:03:36 -04004476 struct path path;
NeilBrown0964a3d2005-06-23 22:04:32 -07004477
Al Viroa63bb992008-08-02 01:03:36 -04004478 status = kern_path(recdir, LOOKUP_FOLLOW, &path);
NeilBrown0964a3d2005-06-23 22:04:32 -07004479 if (status)
4480 return status;
4481 status = -ENOTDIR;
Al Viroa63bb992008-08-02 01:03:36 -04004482 if (S_ISDIR(path.dentry->d_inode->i_mode)) {
NeilBrown0964a3d2005-06-23 22:04:32 -07004483 nfs4_set_recdir(recdir);
4484 status = 0;
4485 }
Al Viroa63bb992008-08-02 01:03:36 -04004486 path_put(&path);
NeilBrown0964a3d2005-06-23 22:04:32 -07004487 return status;
4488}
4489
Jeff Layton3dd98a32008-06-10 08:40:36 -04004490char *
4491nfs4_recoverydir(void)
4492{
4493 return user_recovery_dirname;
4494}