blob: 3787ec11740014a64e13ca3eb336d6fdf80f7310 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002* Copyright (c) 2001 The Regents of the University of Michigan.
3* All rights reserved.
4*
5* Kendrick Smith <kmsmith@umich.edu>
6* Andy Adamson <kandros@umich.edu>
7*
8* Redistribution and use in source and binary forms, with or without
9* modification, are permitted provided that the following conditions
10* are met:
11*
12* 1. Redistributions of source code must retain the above copyright
13* notice, this list of conditions and the following disclaimer.
14* 2. Redistributions in binary form must reproduce the above copyright
15* notice, this list of conditions and the following disclaimer in the
16* documentation and/or other materials provided with the distribution.
17* 3. Neither the name of the University nor the names of its
18* contributors may be used to endorse or promote products derived
19* from this software without specific prior written permission.
20*
21* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
22* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
23* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
24* DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
25* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
26* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
27* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
28* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
29* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
30* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
31* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32*
33*/
34
Dave Hansenaceaf782008-02-15 14:37:31 -080035#include <linux/file.h>
Arnd Bergmannb89f4322010-09-18 15:09:31 +020036#include <linux/fs.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090037#include <linux/slab.h>
NeilBrown0964a3d2005-06-23 22:04:32 -070038#include <linux/namei.h>
Meelap Shahc2f1a552007-07-17 04:04:39 -070039#include <linux/swap.h>
Bryan Schumaker17456802011-07-13 10:50:48 -040040#include <linux/pagemap.h>
Olga Kornievskaia68e76ad2008-12-23 16:17:15 -050041#include <linux/sunrpc/svcauth_gss.h>
Jeff Layton363168b2009-08-14 12:57:56 -040042#include <linux/sunrpc/clnt.h>
Boaz Harrosh9a74af22009-12-03 20:30:56 +020043#include "xdr4.h"
J. Bruce Fields0a3adad2009-11-04 18:12:35 -050044#include "vfs.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070045
46#define NFSDDBG_FACILITY NFSDDBG_PROC
47
48/* Globals */
J. Bruce Fieldscf07d2e2010-02-28 23:20:19 -050049time_t nfsd4_lease = 90; /* default lease time */
J. Bruce Fieldsefc4bb4f2010-03-02 11:04:06 -050050time_t nfsd4_grace = 90;
NeilBrownfd39ca92005-06-23 22:04:03 -070051static time_t boot_time;
Linus Torvalds1da177e2005-04-16 15:20:36 -070052static u32 current_ownerid = 1;
53static u32 current_fileid = 1;
54static u32 current_delegid = 1;
NeilBrownfd39ca92005-06-23 22:04:03 -070055static stateid_t zerostateid; /* bits all 0 */
56static stateid_t onestateid; /* bits all 1 */
Andy Adamsonec6b5d72009-04-03 08:28:28 +030057static u64 current_sessionid = 1;
NeilBrownfd39ca92005-06-23 22:04:03 -070058
59#define ZERO_STATEID(stateid) (!memcmp((stateid), &zerostateid, sizeof(stateid_t)))
60#define ONE_STATEID(stateid) (!memcmp((stateid), &onestateid, sizeof(stateid_t)))
Linus Torvalds1da177e2005-04-16 15:20:36 -070061
Linus Torvalds1da177e2005-04-16 15:20:36 -070062/* forward declarations */
NeilBrownfd39ca92005-06-23 22:04:03 -070063static struct nfs4_stateid * find_stateid(stateid_t *stid, int flags);
Bryan Schumakere1ca12d2011-07-13 11:04:21 -040064static struct nfs4_stateid * search_for_stateid(stateid_t *stid);
65static struct nfs4_delegation * search_for_delegation(stateid_t *stid);
Linus Torvalds1da177e2005-04-16 15:20:36 -070066static struct nfs4_delegation * find_delegation_stateid(struct inode *ino, stateid_t *stid);
NeilBrown0964a3d2005-06-23 22:04:32 -070067static char user_recovery_dirname[PATH_MAX] = "/var/lib/nfs/v4recovery";
68static void nfs4_set_recdir(char *recdir);
Bryan Schumakere1ca12d2011-07-13 11:04:21 -040069static int check_for_locks(struct nfs4_file *filp, struct nfs4_stateowner *lowner);
Linus Torvalds1da177e2005-04-16 15:20:36 -070070
J. Bruce Fields8b671b82009-02-22 14:51:34 -080071/* Locking: */
72
73/* Currently used for almost all code touching nfsv4 state: */
Ingo Molnar353ab6e2006-03-26 01:37:12 -080074static DEFINE_MUTEX(client_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070075
J. Bruce Fields8b671b82009-02-22 14:51:34 -080076/*
77 * Currently used for the del_recall_lru and file hash table. In an
78 * effort to decrease the scope of the client_mutex, this spinlock may
79 * eventually cover more:
80 */
81static DEFINE_SPINLOCK(recall_lock);
82
Christoph Lametere18b8902006-12-06 20:33:20 -080083static struct kmem_cache *stateowner_slab = NULL;
84static struct kmem_cache *file_slab = NULL;
85static struct kmem_cache *stateid_slab = NULL;
86static struct kmem_cache *deleg_slab = NULL;
NeilBrowne60d4392005-06-23 22:03:01 -070087
Linus Torvalds1da177e2005-04-16 15:20:36 -070088void
89nfs4_lock_state(void)
90{
Ingo Molnar353ab6e2006-03-26 01:37:12 -080091 mutex_lock(&client_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070092}
93
94void
95nfs4_unlock_state(void)
96{
Ingo Molnar353ab6e2006-03-26 01:37:12 -080097 mutex_unlock(&client_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070098}
99
100static inline u32
101opaque_hashval(const void *ptr, int nbytes)
102{
103 unsigned char *cptr = (unsigned char *) ptr;
104
105 u32 x = 0;
106 while (nbytes--) {
107 x *= 37;
108 x += *cptr++;
109 }
110 return x;
111}
112
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113static struct list_head del_recall_lru;
114
NeilBrown13cd2182005-06-23 22:03:10 -0700115static inline void
116put_nfs4_file(struct nfs4_file *fi)
117{
J. Bruce Fields8b671b82009-02-22 14:51:34 -0800118 if (atomic_dec_and_lock(&fi->fi_ref, &recall_lock)) {
119 list_del(&fi->fi_hash);
120 spin_unlock(&recall_lock);
121 iput(fi->fi_inode);
122 kmem_cache_free(file_slab, fi);
123 }
NeilBrown13cd2182005-06-23 22:03:10 -0700124}
125
126static inline void
127get_nfs4_file(struct nfs4_file *fi)
128{
J. Bruce Fields8b671b82009-02-22 14:51:34 -0800129 atomic_inc(&fi->fi_ref);
NeilBrown13cd2182005-06-23 22:03:10 -0700130}
131
NeilBrownef0f3392006-04-10 22:55:41 -0700132static int num_delegations;
Meelap Shahc2f1a552007-07-17 04:04:39 -0700133unsigned int max_delegations;
NeilBrownef0f3392006-04-10 22:55:41 -0700134
135/*
136 * Open owner state (share locks)
137 */
138
139/* hash tables for nfs4_stateowner */
140#define OWNER_HASH_BITS 8
141#define OWNER_HASH_SIZE (1 << OWNER_HASH_BITS)
142#define OWNER_HASH_MASK (OWNER_HASH_SIZE - 1)
143
144#define ownerid_hashval(id) \
145 ((id) & OWNER_HASH_MASK)
146#define ownerstr_hashval(clientid, ownername) \
147 (((clientid) + opaque_hashval((ownername.data), (ownername.len))) & OWNER_HASH_MASK)
148
149static struct list_head ownerid_hashtbl[OWNER_HASH_SIZE];
150static struct list_head ownerstr_hashtbl[OWNER_HASH_SIZE];
151
152/* hash table for nfs4_file */
153#define FILE_HASH_BITS 8
154#define FILE_HASH_SIZE (1 << FILE_HASH_BITS)
Shan Wei35079582011-01-14 17:35:59 +0800155
NeilBrownef0f3392006-04-10 22:55:41 -0700156/* hash table for (open)nfs4_stateid */
157#define STATEID_HASH_BITS 10
158#define STATEID_HASH_SIZE (1 << STATEID_HASH_BITS)
159#define STATEID_HASH_MASK (STATEID_HASH_SIZE - 1)
160
161#define file_hashval(x) \
162 hash_ptr(x, FILE_HASH_BITS)
163#define stateid_hashval(owner_id, file_id) \
164 (((owner_id) + (file_id)) & STATEID_HASH_MASK)
165
166static struct list_head file_hashtbl[FILE_HASH_SIZE];
167static struct list_head stateid_hashtbl[STATEID_HASH_SIZE];
168
J. Bruce Fields998db522010-08-07 09:21:41 -0400169static void __nfs4_file_get_access(struct nfs4_file *fp, int oflag)
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400170{
171 BUG_ON(!(fp->fi_fds[oflag] || fp->fi_fds[O_RDWR]));
172 atomic_inc(&fp->fi_access[oflag]);
173}
174
J. Bruce Fields998db522010-08-07 09:21:41 -0400175static void nfs4_file_get_access(struct nfs4_file *fp, int oflag)
176{
177 if (oflag == O_RDWR) {
178 __nfs4_file_get_access(fp, O_RDONLY);
179 __nfs4_file_get_access(fp, O_WRONLY);
180 } else
181 __nfs4_file_get_access(fp, oflag);
182}
183
184static void nfs4_file_put_fd(struct nfs4_file *fp, int oflag)
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400185{
186 if (fp->fi_fds[oflag]) {
187 fput(fp->fi_fds[oflag]);
188 fp->fi_fds[oflag] = NULL;
189 }
190}
191
J. Bruce Fields998db522010-08-07 09:21:41 -0400192static void __nfs4_file_put_access(struct nfs4_file *fp, int oflag)
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400193{
194 if (atomic_dec_and_test(&fp->fi_access[oflag])) {
195 nfs4_file_put_fd(fp, O_RDWR);
196 nfs4_file_put_fd(fp, oflag);
197 }
198}
199
J. Bruce Fields998db522010-08-07 09:21:41 -0400200static void nfs4_file_put_access(struct nfs4_file *fp, int oflag)
201{
202 if (oflag == O_RDWR) {
203 __nfs4_file_put_access(fp, O_RDONLY);
204 __nfs4_file_put_access(fp, O_WRONLY);
205 } else
206 __nfs4_file_put_access(fp, oflag);
207}
208
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209static struct nfs4_delegation *
210alloc_init_deleg(struct nfs4_client *clp, struct nfs4_stateid *stp, struct svc_fh *current_fh, u32 type)
211{
212 struct nfs4_delegation *dp;
213 struct nfs4_file *fp = stp->st_file;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214
215 dprintk("NFSD alloc_init_deleg\n");
J. Bruce Fieldsc3e48082010-07-28 10:08:57 -0400216 /*
217 * Major work on the lease subsystem (for example, to support
218 * calbacks on stat) will be required before we can support
219 * write delegations properly.
220 */
221 if (type != NFS4_OPEN_DELEGATE_READ)
222 return NULL;
Meelap Shah47f99402007-07-17 04:04:40 -0700223 if (fp->fi_had_conflict)
224 return NULL;
Meelap Shahc2f1a552007-07-17 04:04:39 -0700225 if (num_delegations > max_delegations)
NeilBrownef0f3392006-04-10 22:55:41 -0700226 return NULL;
NeilBrown5b2d21c2005-06-23 22:03:04 -0700227 dp = kmem_cache_alloc(deleg_slab, GFP_KERNEL);
228 if (dp == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229 return dp;
NeilBrownef0f3392006-04-10 22:55:41 -0700230 num_delegations++;
NeilBrownea1da632005-06-23 22:04:17 -0700231 INIT_LIST_HEAD(&dp->dl_perfile);
232 INIT_LIST_HEAD(&dp->dl_perclnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233 INIT_LIST_HEAD(&dp->dl_recall_lru);
234 dp->dl_client = clp;
NeilBrown13cd2182005-06-23 22:03:10 -0700235 get_nfs4_file(fp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236 dp->dl_file = fp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237 dp->dl_type = type;
J. Bruce Fieldse4e83ea2010-04-22 16:21:39 -0400238 dp->dl_stateid.si_boot = boot_time;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700239 dp->dl_stateid.si_stateownerid = current_delegid++;
240 dp->dl_stateid.si_fileid = 0;
241 dp->dl_stateid.si_generation = 0;
J. Bruce Fields6c02eaa2009-02-02 17:30:51 -0500242 fh_copy_shallow(&dp->dl_fh, &current_fh->fh_handle);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243 dp->dl_time = 0;
244 atomic_set(&dp->dl_count, 1);
J. Bruce Fieldsb5a1a812010-03-03 14:52:55 -0500245 INIT_WORK(&dp->dl_recall.cb_work, nfsd4_do_callback_rpc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246 return dp;
247}
248
249void
250nfs4_put_delegation(struct nfs4_delegation *dp)
251{
252 if (atomic_dec_and_test(&dp->dl_count)) {
253 dprintk("NFSD: freeing dp %p\n",dp);
NeilBrown13cd2182005-06-23 22:03:10 -0700254 put_nfs4_file(dp->dl_file);
NeilBrown5b2d21c2005-06-23 22:03:04 -0700255 kmem_cache_free(deleg_slab, dp);
NeilBrownef0f3392006-04-10 22:55:41 -0700256 num_delegations--;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257 }
258}
259
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -0500260static void nfs4_put_deleg_lease(struct nfs4_file *fp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261{
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -0500262 if (atomic_dec_and_test(&fp->fi_delegees)) {
263 vfs_setlease(fp->fi_deleg_file, F_UNLCK, &fp->fi_lease);
264 fp->fi_lease = NULL;
J. Bruce Fields4ee63622011-04-15 18:08:26 -0400265 fput(fp->fi_deleg_file);
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -0500266 fp->fi_deleg_file = NULL;
267 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268}
269
270/* Called under the state lock. */
271static void
272unhash_delegation(struct nfs4_delegation *dp)
273{
NeilBrownea1da632005-06-23 22:04:17 -0700274 list_del_init(&dp->dl_perclnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275 spin_lock(&recall_lock);
J. Bruce Fields5d926e82011-02-07 16:53:46 -0500276 list_del_init(&dp->dl_perfile);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277 list_del_init(&dp->dl_recall_lru);
278 spin_unlock(&recall_lock);
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -0500279 nfs4_put_deleg_lease(dp->dl_file);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700280 nfs4_put_delegation(dp);
281}
282
283/*
284 * SETCLIENTID state
285 */
286
Benny Halevy36acb662010-05-12 00:13:04 +0300287/* client_lock protects the client lru list and session hash table */
Benny Halevy9089f1b2010-05-12 00:12:26 +0300288static DEFINE_SPINLOCK(client_lock);
289
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290/* Hash tables for nfs4_clientid state */
291#define CLIENT_HASH_BITS 4
292#define CLIENT_HASH_SIZE (1 << CLIENT_HASH_BITS)
293#define CLIENT_HASH_MASK (CLIENT_HASH_SIZE - 1)
294
295#define clientid_hashval(id) \
296 ((id) & CLIENT_HASH_MASK)
NeilBrowna55370a2005-06-23 22:03:52 -0700297#define clientstr_hashval(name) \
298 (opaque_hashval((name), 8) & CLIENT_HASH_MASK)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299/*
300 * reclaim_str_hashtbl[] holds known client info from previous reset/reboot
301 * used in reboot/reset lease grace period processing
302 *
303 * conf_id_hashtbl[], and conf_str_hashtbl[] hold confirmed
304 * setclientid_confirmed info.
305 *
306 * unconf_str_hastbl[] and unconf_id_hashtbl[] hold unconfirmed
307 * setclientid info.
308 *
309 * client_lru holds client queue ordered by nfs4_client.cl_time
310 * for lease renewal.
311 *
312 * close_lru holds (open) stateowner queue ordered by nfs4_stateowner.so_time
313 * for last close replay.
314 */
315static struct list_head reclaim_str_hashtbl[CLIENT_HASH_SIZE];
316static int reclaim_str_hashtbl_size = 0;
317static struct list_head conf_id_hashtbl[CLIENT_HASH_SIZE];
318static struct list_head conf_str_hashtbl[CLIENT_HASH_SIZE];
319static struct list_head unconf_str_hashtbl[CLIENT_HASH_SIZE];
320static struct list_head unconf_id_hashtbl[CLIENT_HASH_SIZE];
321static struct list_head client_lru;
322static struct list_head close_lru;
323
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400324/*
325 * We store the NONE, READ, WRITE, and BOTH bits separately in the
326 * st_{access,deny}_bmap field of the stateid, in order to track not
327 * only what share bits are currently in force, but also what
328 * combinations of share bits previous opens have used. This allows us
329 * to enforce the recommendation of rfc 3530 14.2.19 that the server
330 * return an error if the client attempt to downgrade to a combination
331 * of share bits not explicable by closing some of its previous opens.
332 *
333 * XXX: This enforcement is actually incomplete, since we don't keep
334 * track of access/deny bit combinations; so, e.g., we allow:
335 *
336 * OPEN allow read, deny write
337 * OPEN allow both, deny none
338 * DOWNGRADE allow read, deny none
339 *
340 * which we should reject.
341 */
342static void
343set_access(unsigned int *access, unsigned long bmap) {
344 int i;
345
346 *access = 0;
347 for (i = 1; i < 4; i++) {
348 if (test_bit(i, &bmap))
349 *access |= i;
350 }
351}
352
353static void
354set_deny(unsigned int *deny, unsigned long bmap) {
355 int i;
356
357 *deny = 0;
358 for (i = 0; i < 4; i++) {
359 if (test_bit(i, &bmap))
360 *deny |= i ;
361 }
362}
363
364static int
365test_share(struct nfs4_stateid *stp, struct nfsd4_open *open) {
366 unsigned int access, deny;
367
368 set_access(&access, stp->st_access_bmap);
369 set_deny(&deny, stp->st_deny_bmap);
370 if ((access & open->op_share_deny) || (deny & open->op_share_access))
371 return 0;
372 return 1;
373}
374
375static int nfs4_access_to_omode(u32 access)
376{
J. Bruce Fields8f34a432010-09-02 15:23:16 -0400377 switch (access & NFS4_SHARE_ACCESS_BOTH) {
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -0400378 case NFS4_SHARE_ACCESS_READ:
379 return O_RDONLY;
380 case NFS4_SHARE_ACCESS_WRITE:
381 return O_WRONLY;
382 case NFS4_SHARE_ACCESS_BOTH:
383 return O_RDWR;
384 }
385 BUG();
386}
387
J. Bruce Fields529d7b22011-03-02 23:48:33 -0500388static void unhash_generic_stateid(struct nfs4_stateid *stp)
389{
390 list_del(&stp->st_hash);
391 list_del(&stp->st_perfile);
392 list_del(&stp->st_perstateowner);
393}
394
395static void free_generic_stateid(struct nfs4_stateid *stp)
396{
J. Bruce Fields499f3ed2011-06-27 16:57:12 -0400397 int i;
J. Bruce Fields0997b172011-03-02 18:01:35 -0500398
J. Bruce Fields23fcf2e2011-03-28 15:15:09 +0800399 if (stp->st_access_bmap) {
J. Bruce Fields499f3ed2011-06-27 16:57:12 -0400400 for (i = 1; i < 4; i++) {
401 if (test_bit(i, &stp->st_access_bmap))
402 nfs4_file_put_access(stp->st_file,
403 nfs4_access_to_omode(i));
404 }
J. Bruce Fields23fcf2e2011-03-28 15:15:09 +0800405 }
OGAWA Hirofumia96e5b92011-04-18 11:48:55 -0400406 put_nfs4_file(stp->st_file);
J. Bruce Fields529d7b22011-03-02 23:48:33 -0500407 kmem_cache_free(stateid_slab, stp);
408}
409
410static void release_lock_stateid(struct nfs4_stateid *stp)
411{
412 struct file *file;
413
414 unhash_generic_stateid(stp);
415 file = find_any_file(stp->st_file);
416 if (file)
417 locks_remove_posix(file, (fl_owner_t)stp->st_stateowner);
418 free_generic_stateid(stp);
419}
420
421static void unhash_lockowner(struct nfs4_stateowner *sop)
422{
423 struct nfs4_stateid *stp;
424
425 list_del(&sop->so_idhash);
426 list_del(&sop->so_strhash);
427 list_del(&sop->so_perstateid);
428 while (!list_empty(&sop->so_stateids)) {
429 stp = list_first_entry(&sop->so_stateids,
430 struct nfs4_stateid, st_perstateowner);
431 release_lock_stateid(stp);
432 }
433}
434
435static void release_lockowner(struct nfs4_stateowner *sop)
436{
437 unhash_lockowner(sop);
438 nfs4_put_stateowner(sop);
439}
440
441static void
442release_stateid_lockowners(struct nfs4_stateid *open_stp)
443{
444 struct nfs4_stateowner *lock_sop;
445
446 while (!list_empty(&open_stp->st_lockowners)) {
447 lock_sop = list_entry(open_stp->st_lockowners.next,
448 struct nfs4_stateowner, so_perstateid);
449 /* list_del(&open_stp->st_lockowners); */
450 BUG_ON(lock_sop->so_is_open_owner);
451 release_lockowner(lock_sop);
452 }
453}
454
J. Bruce Fields22839632009-01-11 14:27:17 -0500455static void release_open_stateid(struct nfs4_stateid *stp)
456{
457 unhash_generic_stateid(stp);
458 release_stateid_lockowners(stp);
J. Bruce Fields22839632009-01-11 14:27:17 -0500459 free_generic_stateid(stp);
460}
461
J. Bruce Fieldsf044ff82009-01-11 15:24:04 -0500462static void unhash_openowner(struct nfs4_stateowner *sop)
J. Bruce Fieldsf1d110c2009-01-11 14:37:31 -0500463{
464 struct nfs4_stateid *stp;
465
466 list_del(&sop->so_idhash);
467 list_del(&sop->so_strhash);
J. Bruce Fieldsf044ff82009-01-11 15:24:04 -0500468 list_del(&sop->so_perclient);
469 list_del(&sop->so_perstateid); /* XXX: necessary? */
J. Bruce Fieldsf1d110c2009-01-11 14:37:31 -0500470 while (!list_empty(&sop->so_stateids)) {
J. Bruce Fieldsf044ff82009-01-11 15:24:04 -0500471 stp = list_first_entry(&sop->so_stateids,
472 struct nfs4_stateid, st_perstateowner);
473 release_open_stateid(stp);
J. Bruce Fieldsf1d110c2009-01-11 14:37:31 -0500474 }
475}
476
J. Bruce Fieldsf044ff82009-01-11 15:24:04 -0500477static void release_openowner(struct nfs4_stateowner *sop)
J. Bruce Fieldsf1d110c2009-01-11 14:37:31 -0500478{
J. Bruce Fieldsf044ff82009-01-11 15:24:04 -0500479 unhash_openowner(sop);
J. Bruce Fieldsf1d110c2009-01-11 14:37:31 -0500480 list_del(&sop->so_close_lru);
481 nfs4_put_stateowner(sop);
482}
483
Marc Eshel5282fd72009-04-03 08:27:52 +0300484#define SESSION_HASH_SIZE 512
485static struct list_head sessionid_hashtbl[SESSION_HASH_SIZE];
486
487static inline int
488hash_sessionid(struct nfs4_sessionid *sessionid)
489{
490 struct nfsd4_sessionid *sid = (struct nfsd4_sessionid *)sessionid;
491
492 return sid->sequence % SESSION_HASH_SIZE;
493}
494
495static inline void
496dump_sessionid(const char *fn, struct nfs4_sessionid *sessionid)
497{
498 u32 *ptr = (u32 *)(&sessionid->data[0]);
499 dprintk("%s: %u:%u:%u:%u\n", fn, ptr[0], ptr[1], ptr[2], ptr[3]);
500}
501
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300502static void
503gen_sessionid(struct nfsd4_session *ses)
504{
505 struct nfs4_client *clp = ses->se_client;
506 struct nfsd4_sessionid *sid;
507
508 sid = (struct nfsd4_sessionid *)ses->se_sessionid.data;
509 sid->clientid = clp->cl_clientid;
510 sid->sequence = current_sessionid++;
511 sid->reserved = 0;
512}
513
514/*
Andy Adamsona6496372009-08-28 08:45:01 -0400515 * The protocol defines ca_maxresponssize_cached to include the size of
516 * the rpc header, but all we need to cache is the data starting after
517 * the end of the initial SEQUENCE operation--the rest we regenerate
518 * each time. Therefore we can advertise a ca_maxresponssize_cached
519 * value that is the number of bytes in our cache plus a few additional
520 * bytes. In order to stay on the safe side, and not promise more than
521 * we can cache, those additional bytes must be the minimum possible: 24
522 * bytes of rpc header (xid through accept state, with AUTH_NULL
523 * verifier), 12 for the compound header (with zero-length tag), and 44
524 * for the SEQUENCE op response:
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300525 */
Andy Adamsona6496372009-08-28 08:45:01 -0400526#define NFSD_MIN_HDR_SEQ_SZ (24 + 12 + 44)
527
Andy Adamson557ce262009-08-28 08:45:04 -0400528static void
529free_session_slots(struct nfsd4_session *ses)
530{
531 int i;
532
533 for (i = 0; i < ses->se_fchannel.maxreqs; i++)
534 kfree(ses->se_slots[i]);
535}
536
J. Bruce Fieldsefe0cb62009-10-24 20:52:16 -0400537/*
538 * We don't actually need to cache the rpc and session headers, so we
539 * can allocate a little less for each slot:
540 */
541static inline int slot_bytes(struct nfsd4_channel_attrs *ca)
542{
543 return ca->maxresp_cached - NFSD_MIN_HDR_SEQ_SZ;
544}
545
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400546static int nfsd4_sanitize_slot_size(u32 size)
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300547{
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400548 size -= NFSD_MIN_HDR_SEQ_SZ; /* We don't cache the rpc header */
549 size = min_t(u32, size, NFSD_SLOT_CACHE_SIZE);
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300550
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400551 return size;
552}
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300553
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400554/*
555 * XXX: If we run out of reserved DRC memory we could (up to a point)
556 * re-negotiate active sessions and reduce their slot usage to make
557 * rooom for new connections. For now we just fail the create session.
558 */
559static int nfsd4_get_drc_mem(int slotsize, u32 num)
560{
561 int avail;
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300562
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400563 num = min_t(u32, num, NFSD_MAX_SLOTS_PER_SESSION);
Andy Adamson557ce262009-08-28 08:45:04 -0400564
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400565 spin_lock(&nfsd_drc_lock);
566 avail = min_t(int, NFSD_MAX_MEM_PER_SESSION,
567 nfsd_drc_max_mem - nfsd_drc_mem_used);
568 num = min_t(int, num, avail / slotsize);
569 nfsd_drc_mem_used += num * slotsize;
570 spin_unlock(&nfsd_drc_lock);
571
572 return num;
573}
574
575static void nfsd4_put_drc_mem(int slotsize, int num)
576{
577 spin_lock(&nfsd_drc_lock);
578 nfsd_drc_mem_used -= slotsize * num;
579 spin_unlock(&nfsd_drc_lock);
580}
581
582static struct nfsd4_session *alloc_session(int slotsize, int numslots)
583{
584 struct nfsd4_session *new;
585 int mem, i;
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300586
J. Bruce Fieldsc23753d2010-09-27 16:22:30 -0400587 BUILD_BUG_ON(NFSD_MAX_SLOTS_PER_SESSION * sizeof(struct nfsd4_slot *)
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400588 + sizeof(struct nfsd4_session) > PAGE_SIZE);
589 mem = numslots * sizeof(struct nfsd4_slot *);
Andy Adamson557ce262009-08-28 08:45:04 -0400590
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400591 new = kzalloc(sizeof(*new) + mem, GFP_KERNEL);
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300592 if (!new)
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400593 return NULL;
Andy Adamson557ce262009-08-28 08:45:04 -0400594 /* allocate each struct nfsd4_slot and data cache in one piece */
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400595 for (i = 0; i < numslots; i++) {
596 mem = sizeof(struct nfsd4_slot) + slotsize;
597 new->se_slots[i] = kzalloc(mem, GFP_KERNEL);
598 if (!new->se_slots[i])
Andy Adamson557ce262009-08-28 08:45:04 -0400599 goto out_free;
Andy Adamson557ce262009-08-28 08:45:04 -0400600 }
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400601 return new;
602out_free:
603 while (i--)
604 kfree(new->se_slots[i]);
605 kfree(new);
606 return NULL;
607}
608
609static void init_forechannel_attrs(struct nfsd4_channel_attrs *new, struct nfsd4_channel_attrs *req, int numslots, int slotsize)
610{
611 u32 maxrpc = nfsd_serv->sv_max_mesg;
612
613 new->maxreqs = numslots;
Mi Jinlongd2b21742011-03-10 17:43:37 +0800614 new->maxresp_cached = min_t(u32, req->maxresp_cached,
615 slotsize + NFSD_MIN_HDR_SEQ_SZ);
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400616 new->maxreq_sz = min_t(u32, req->maxreq_sz, maxrpc);
617 new->maxresp_sz = min_t(u32, req->maxresp_sz, maxrpc);
618 new->maxops = min_t(u32, req->maxops, NFSD_MAX_OPS_PER_COMPOUND);
619}
620
J. Bruce Fields19cf5c02010-06-06 18:37:16 -0400621static void free_conn(struct nfsd4_conn *c)
622{
623 svc_xprt_put(c->cn_xprt);
624 kfree(c);
625}
626
627static void nfsd4_conn_lost(struct svc_xpt_user *u)
628{
629 struct nfsd4_conn *c = container_of(u, struct nfsd4_conn, cn_xpt_user);
630 struct nfs4_client *clp = c->cn_session->se_client;
631
632 spin_lock(&clp->cl_lock);
633 if (!list_empty(&c->cn_persession)) {
634 list_del(&c->cn_persession);
635 free_conn(c);
636 }
637 spin_unlock(&clp->cl_lock);
J. Bruce Fieldseea49802010-11-18 08:34:12 -0500638 nfsd4_probe_callback(clp);
J. Bruce Fields19cf5c02010-06-06 18:37:16 -0400639}
640
J. Bruce Fieldsd29c3742010-06-15 17:34:11 -0400641static struct nfsd4_conn *alloc_conn(struct svc_rqst *rqstp, u32 flags)
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400642{
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400643 struct nfsd4_conn *conn;
644
645 conn = kmalloc(sizeof(struct nfsd4_conn), GFP_KERNEL);
646 if (!conn)
J. Bruce Fieldsdb906812010-09-29 15:29:32 -0400647 return NULL;
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400648 svc_xprt_get(rqstp->rq_xprt);
649 conn->cn_xprt = rqstp->rq_xprt;
J. Bruce Fieldsd29c3742010-06-15 17:34:11 -0400650 conn->cn_flags = flags;
J. Bruce Fieldsdb906812010-09-29 15:29:32 -0400651 INIT_LIST_HEAD(&conn->cn_xpt_user.list);
652 return conn;
653}
654
J. Bruce Fields328ead22010-09-29 16:11:06 -0400655static void __nfsd4_hash_conn(struct nfsd4_conn *conn, struct nfsd4_session *ses)
656{
657 conn->cn_session = ses;
658 list_add(&conn->cn_persession, &ses->se_conns);
659}
660
J. Bruce Fieldsdb906812010-09-29 15:29:32 -0400661static void nfsd4_hash_conn(struct nfsd4_conn *conn, struct nfsd4_session *ses)
662{
663 struct nfs4_client *clp = ses->se_client;
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400664
665 spin_lock(&clp->cl_lock);
J. Bruce Fields328ead22010-09-29 16:11:06 -0400666 __nfsd4_hash_conn(conn, ses);
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400667 spin_unlock(&clp->cl_lock);
J. Bruce Fieldsdb906812010-09-29 15:29:32 -0400668}
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400669
J. Bruce Fields21b75b02010-10-26 10:07:17 -0400670static int nfsd4_register_conn(struct nfsd4_conn *conn)
J. Bruce Fieldsdb906812010-09-29 15:29:32 -0400671{
J. Bruce Fields19cf5c02010-06-06 18:37:16 -0400672 conn->cn_xpt_user.callback = nfsd4_conn_lost;
J. Bruce Fields21b75b02010-10-26 10:07:17 -0400673 return register_xpt_user(conn->cn_xprt, &conn->cn_xpt_user);
J. Bruce Fieldsdb906812010-09-29 15:29:32 -0400674}
675
J. Bruce Fields1d1bc8f2010-10-04 23:12:59 -0400676static __be32 nfsd4_new_conn(struct svc_rqst *rqstp, struct nfsd4_session *ses, u32 dir)
J. Bruce Fieldsdb906812010-09-29 15:29:32 -0400677{
678 struct nfsd4_conn *conn;
J. Bruce Fields21b75b02010-10-26 10:07:17 -0400679 int ret;
J. Bruce Fieldsdb906812010-09-29 15:29:32 -0400680
J. Bruce Fields1d1bc8f2010-10-04 23:12:59 -0400681 conn = alloc_conn(rqstp, dir);
J. Bruce Fieldsdb906812010-09-29 15:29:32 -0400682 if (!conn)
683 return nfserr_jukebox;
684 nfsd4_hash_conn(conn, ses);
J. Bruce Fields21b75b02010-10-26 10:07:17 -0400685 ret = nfsd4_register_conn(conn);
686 if (ret)
687 /* oops; xprt is already down: */
688 nfsd4_conn_lost(&conn->cn_xpt_user);
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400689 return nfs_ok;
690}
691
J. Bruce Fields1d1bc8f2010-10-04 23:12:59 -0400692static __be32 nfsd4_new_conn_from_crses(struct svc_rqst *rqstp, struct nfsd4_session *ses)
693{
694 u32 dir = NFS4_CDFC4_FORE;
695
696 if (ses->se_flags & SESSION4_BACK_CHAN)
697 dir |= NFS4_CDFC4_BACK;
698
699 return nfsd4_new_conn(rqstp, ses, dir);
700}
701
702/* must be called under client_lock */
J. Bruce Fields19cf5c02010-06-06 18:37:16 -0400703static void nfsd4_del_conns(struct nfsd4_session *s)
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400704{
J. Bruce Fields19cf5c02010-06-06 18:37:16 -0400705 struct nfs4_client *clp = s->se_client;
706 struct nfsd4_conn *c;
707
708 spin_lock(&clp->cl_lock);
709 while (!list_empty(&s->se_conns)) {
710 c = list_first_entry(&s->se_conns, struct nfsd4_conn, cn_persession);
711 list_del_init(&c->cn_persession);
712 spin_unlock(&clp->cl_lock);
713
714 unregister_xpt_user(c->cn_xprt, &c->cn_xpt_user);
715 free_conn(c);
716
717 spin_lock(&clp->cl_lock);
718 }
719 spin_unlock(&clp->cl_lock);
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400720}
721
722void free_session(struct kref *kref)
723{
724 struct nfsd4_session *ses;
725 int mem;
726
727 ses = container_of(kref, struct nfsd4_session, se_ref);
J. Bruce Fields19cf5c02010-06-06 18:37:16 -0400728 nfsd4_del_conns(ses);
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400729 spin_lock(&nfsd_drc_lock);
730 mem = ses->se_fchannel.maxreqs * slot_bytes(&ses->se_fchannel);
731 nfsd_drc_mem_used -= mem;
732 spin_unlock(&nfsd_drc_lock);
733 free_session_slots(ses);
734 kfree(ses);
735}
736
J. Bruce Fieldsac7c46f2010-06-14 19:01:57 -0400737static 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 -0400738{
739 struct nfsd4_session *new;
740 struct nfsd4_channel_attrs *fchan = &cses->fore_channel;
741 int numslots, slotsize;
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400742 int status;
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400743 int idx;
744
745 /*
746 * Note decreasing slot size below client's request may
747 * make it difficult for client to function correctly, whereas
748 * decreasing the number of slots will (just?) affect
749 * performance. When short on memory we therefore prefer to
750 * decrease number of slots instead of their size.
751 */
752 slotsize = nfsd4_sanitize_slot_size(fchan->maxresp_cached);
753 numslots = nfsd4_get_drc_mem(slotsize, fchan->maxreqs);
Mi Jinlongced6dfe2010-11-11 18:03:50 +0800754 if (numslots < 1)
755 return NULL;
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400756
757 new = alloc_session(slotsize, numslots);
758 if (!new) {
759 nfsd4_put_drc_mem(slotsize, fchan->maxreqs);
J. Bruce Fieldsac7c46f2010-06-14 19:01:57 -0400760 return NULL;
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400761 }
762 init_forechannel_attrs(&new->se_fchannel, fchan, numslots, slotsize);
Andy Adamson557ce262009-08-28 08:45:04 -0400763
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300764 new->se_client = clp;
765 gen_sessionid(new);
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300766
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400767 INIT_LIST_HEAD(&new->se_conns);
768
J. Bruce Fieldsac7c46f2010-06-14 19:01:57 -0400769 new->se_cb_seq_nr = 1;
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300770 new->se_flags = cses->flags;
J. Bruce Fields8b5ce5c2010-10-19 17:31:50 -0400771 new->se_cb_prog = cses->callback_prog;
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300772 kref_init(&new->se_ref);
J. Bruce Fields5b6feee2010-09-27 17:12:05 -0400773 idx = hash_sessionid(&new->se_sessionid);
Benny Halevy9089f1b2010-05-12 00:12:26 +0300774 spin_lock(&client_lock);
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300775 list_add(&new->se_hash, &sessionid_hashtbl[idx]);
J. Bruce Fields4c649372010-06-15 14:22:37 -0400776 spin_lock(&clp->cl_lock);
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300777 list_add(&new->se_perclnt, &clp->cl_sessions);
J. Bruce Fields4c649372010-06-15 14:22:37 -0400778 spin_unlock(&clp->cl_lock);
Benny Halevy9089f1b2010-05-12 00:12:26 +0300779 spin_unlock(&client_lock);
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300780
J. Bruce Fields1d1bc8f2010-10-04 23:12:59 -0400781 status = nfsd4_new_conn_from_crses(rqstp, new);
J. Bruce Fieldsac7c46f2010-06-14 19:01:57 -0400782 /* whoops: benny points out, status is ignored! (err, or bogus) */
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400783 if (status) {
784 free_session(&new->se_ref);
J. Bruce Fieldsac7c46f2010-06-14 19:01:57 -0400785 return NULL;
J. Bruce Fieldsc7662512010-06-06 18:12:14 -0400786 }
J. Bruce Fieldsdcbeaa62010-06-15 17:25:45 -0400787 if (cses->flags & SESSION4_BACK_CHAN) {
J. Bruce Fieldsedd76782010-06-14 22:26:31 -0400788 struct sockaddr *sa = svc_addr(rqstp);
J. Bruce Fieldsdcbeaa62010-06-15 17:25:45 -0400789 /*
790 * This is a little silly; with sessions there's no real
791 * use for the callback address. Use the peer address
792 * as a reasonable default for now, but consider fixing
793 * the rpc client not to require an address in the
794 * future:
795 */
J. Bruce Fieldsedd76782010-06-14 22:26:31 -0400796 rpc_copy_addr((struct sockaddr *)&clp->cl_cb_conn.cb_addr, sa);
797 clp->cl_cb_conn.cb_addrlen = svc_addr_len(sa);
J. Bruce Fieldsedd76782010-06-14 22:26:31 -0400798 }
J. Bruce Fieldsdcbeaa62010-06-15 17:25:45 -0400799 nfsd4_probe_callback(clp);
J. Bruce Fieldsac7c46f2010-06-14 19:01:57 -0400800 return new;
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300801}
802
Benny Halevy9089f1b2010-05-12 00:12:26 +0300803/* caller must hold client_lock */
Marc Eshel5282fd72009-04-03 08:27:52 +0300804static struct nfsd4_session *
805find_in_sessionid_hashtbl(struct nfs4_sessionid *sessionid)
806{
807 struct nfsd4_session *elem;
808 int idx;
809
810 dump_sessionid(__func__, sessionid);
811 idx = hash_sessionid(sessionid);
Marc Eshel5282fd72009-04-03 08:27:52 +0300812 /* Search in the appropriate list */
813 list_for_each_entry(elem, &sessionid_hashtbl[idx], se_hash) {
Marc Eshel5282fd72009-04-03 08:27:52 +0300814 if (!memcmp(elem->se_sessionid.data, sessionid->data,
815 NFS4_MAX_SESSIONID_LEN)) {
816 return elem;
817 }
818 }
819
820 dprintk("%s: session not found\n", __func__);
821 return NULL;
822}
823
Benny Halevy9089f1b2010-05-12 00:12:26 +0300824/* caller must hold client_lock */
Andy Adamson7116ed62009-04-03 08:27:43 +0300825static void
Marc Eshel5282fd72009-04-03 08:27:52 +0300826unhash_session(struct nfsd4_session *ses)
Andy Adamson7116ed62009-04-03 08:27:43 +0300827{
828 list_del(&ses->se_hash);
J. Bruce Fields4c649372010-06-15 14:22:37 -0400829 spin_lock(&ses->se_client->cl_lock);
Andy Adamson7116ed62009-04-03 08:27:43 +0300830 list_del(&ses->se_perclnt);
J. Bruce Fields4c649372010-06-15 14:22:37 -0400831 spin_unlock(&ses->se_client->cl_lock);
Marc Eshel5282fd72009-04-03 08:27:52 +0300832}
833
Benny Halevy36acb662010-05-12 00:13:04 +0300834/* must be called under the client_lock */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700835static inline void
Benny Halevy36acb662010-05-12 00:13:04 +0300836renew_client_locked(struct nfs4_client *clp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700837{
Benny Halevy07cd4902010-05-12 00:13:41 +0300838 if (is_client_expired(clp)) {
839 dprintk("%s: client (clientid %08x/%08x) already expired\n",
840 __func__,
841 clp->cl_clientid.cl_boot,
842 clp->cl_clientid.cl_id);
843 return;
844 }
845
Linus Torvalds1da177e2005-04-16 15:20:36 -0700846 /*
847 * Move client to the end to the LRU list.
848 */
849 dprintk("renewing client (clientid %08x/%08x)\n",
850 clp->cl_clientid.cl_boot,
851 clp->cl_clientid.cl_id);
852 list_move_tail(&clp->cl_lru, &client_lru);
853 clp->cl_time = get_seconds();
854}
855
Benny Halevy36acb662010-05-12 00:13:04 +0300856static inline void
857renew_client(struct nfs4_client *clp)
858{
859 spin_lock(&client_lock);
860 renew_client_locked(clp);
861 spin_unlock(&client_lock);
862}
863
Linus Torvalds1da177e2005-04-16 15:20:36 -0700864/* SETCLIENTID and SETCLIENTID_CONFIRM Helper functions */
865static int
866STALE_CLIENTID(clientid_t *clid)
867{
868 if (clid->cl_boot == boot_time)
869 return 0;
Andy Adamson60adfc52009-04-03 08:28:50 +0300870 dprintk("NFSD stale clientid (%08x/%08x) boot_time %08lx\n",
871 clid->cl_boot, clid->cl_id, boot_time);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700872 return 1;
873}
874
875/*
876 * XXX Should we use a slab cache ?
877 * This type of memory management is somewhat inefficient, but we use it
878 * anyway since SETCLIENTID is not a common operation.
879 */
J. Bruce Fields35bba9a2007-11-21 22:07:08 -0500880static struct nfs4_client *alloc_client(struct xdr_netobj name)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700881{
882 struct nfs4_client *clp;
883
J. Bruce Fields35bba9a2007-11-21 22:07:08 -0500884 clp = kzalloc(sizeof(struct nfs4_client), GFP_KERNEL);
885 if (clp == NULL)
886 return NULL;
887 clp->cl_name.data = kmalloc(name.len, GFP_KERNEL);
888 if (clp->cl_name.data == NULL) {
889 kfree(clp);
890 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700891 }
J. Bruce Fields35bba9a2007-11-21 22:07:08 -0500892 memcpy(clp->cl_name.data, name.data, name.len);
893 clp->cl_name.len = name.len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700894 return clp;
895}
896
897static inline void
898free_client(struct nfs4_client *clp)
899{
J. Bruce Fields792c95d2010-10-12 19:55:25 -0400900 while (!list_empty(&clp->cl_sessions)) {
901 struct nfsd4_session *ses;
902 ses = list_entry(clp->cl_sessions.next, struct nfsd4_session,
903 se_perclnt);
904 list_del(&ses->se_perclnt);
905 nfsd4_put_session(ses);
906 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700907 if (clp->cl_cred.cr_group_info)
908 put_group_info(clp->cl_cred.cr_group_info);
Olga Kornievskaia68e76ad2008-12-23 16:17:15 -0500909 kfree(clp->cl_principal);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700910 kfree(clp->cl_name.data);
911 kfree(clp);
912}
913
Benny Halevyd7682982010-05-12 00:13:54 +0300914void
915release_session_client(struct nfsd4_session *session)
916{
917 struct nfs4_client *clp = session->se_client;
918
919 if (!atomic_dec_and_lock(&clp->cl_refcount, &client_lock))
920 return;
921 if (is_client_expired(clp)) {
922 free_client(clp);
923 session->se_client = NULL;
924 } else
925 renew_client_locked(clp);
926 spin_unlock(&client_lock);
Benny Halevyd7682982010-05-12 00:13:54 +0300927}
928
Benny Halevy84d38ac2010-05-12 00:13:16 +0300929/* must be called under the client_lock */
930static inline void
931unhash_client_locked(struct nfs4_client *clp)
932{
J. Bruce Fields792c95d2010-10-12 19:55:25 -0400933 struct nfsd4_session *ses;
934
Benny Halevy07cd4902010-05-12 00:13:41 +0300935 mark_client_expired(clp);
Benny Halevy84d38ac2010-05-12 00:13:16 +0300936 list_del(&clp->cl_lru);
J. Bruce Fields4c649372010-06-15 14:22:37 -0400937 spin_lock(&clp->cl_lock);
J. Bruce Fields792c95d2010-10-12 19:55:25 -0400938 list_for_each_entry(ses, &clp->cl_sessions, se_perclnt)
939 list_del_init(&ses->se_hash);
J. Bruce Fields4c649372010-06-15 14:22:37 -0400940 spin_unlock(&clp->cl_lock);
Benny Halevy84d38ac2010-05-12 00:13:16 +0300941}
942
Linus Torvalds1da177e2005-04-16 15:20:36 -0700943static void
944expire_client(struct nfs4_client *clp)
945{
946 struct nfs4_stateowner *sop;
947 struct nfs4_delegation *dp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700948 struct list_head reaplist;
949
Linus Torvalds1da177e2005-04-16 15:20:36 -0700950 INIT_LIST_HEAD(&reaplist);
951 spin_lock(&recall_lock);
NeilBrownea1da632005-06-23 22:04:17 -0700952 while (!list_empty(&clp->cl_delegations)) {
953 dp = list_entry(clp->cl_delegations.next, struct nfs4_delegation, dl_perclnt);
NeilBrownea1da632005-06-23 22:04:17 -0700954 list_del_init(&dp->dl_perclnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700955 list_move(&dp->dl_recall_lru, &reaplist);
956 }
957 spin_unlock(&recall_lock);
958 while (!list_empty(&reaplist)) {
959 dp = list_entry(reaplist.next, struct nfs4_delegation, dl_recall_lru);
960 list_del_init(&dp->dl_recall_lru);
961 unhash_delegation(dp);
962 }
NeilBrownea1da632005-06-23 22:04:17 -0700963 while (!list_empty(&clp->cl_openowners)) {
964 sop = list_entry(clp->cl_openowners.next, struct nfs4_stateowner, so_perclient);
J. Bruce Fieldsf044ff82009-01-11 15:24:04 -0500965 release_openowner(sop);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700966 }
J. Bruce Fields6ff8da02010-06-04 20:04:45 -0400967 nfsd4_shutdown_callback(clp);
J. Bruce Fields2bf23872010-03-08 12:37:27 -0500968 if (clp->cl_cb_conn.cb_xprt)
969 svc_xprt_put(clp->cl_cb_conn.cb_xprt);
Benny Halevy84d38ac2010-05-12 00:13:16 +0300970 list_del(&clp->cl_idhash);
971 list_del(&clp->cl_strhash);
972 spin_lock(&client_lock);
973 unhash_client_locked(clp);
Benny Halevy46583e22010-05-12 00:13:29 +0300974 if (atomic_read(&clp->cl_refcount) == 0)
975 free_client(clp);
Benny Halevy84d38ac2010-05-12 00:13:16 +0300976 spin_unlock(&client_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700977}
978
J. Bruce Fields35bba9a2007-11-21 22:07:08 -0500979static void copy_verf(struct nfs4_client *target, nfs4_verifier *source)
980{
981 memcpy(target->cl_verifier.data, source->data,
982 sizeof(target->cl_verifier.data));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700983}
984
J. Bruce Fields35bba9a2007-11-21 22:07:08 -0500985static void copy_clid(struct nfs4_client *target, struct nfs4_client *source)
986{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700987 target->cl_clientid.cl_boot = source->cl_clientid.cl_boot;
988 target->cl_clientid.cl_id = source->cl_clientid.cl_id;
989}
990
J. Bruce Fields35bba9a2007-11-21 22:07:08 -0500991static void copy_cred(struct svc_cred *target, struct svc_cred *source)
992{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700993 target->cr_uid = source->cr_uid;
994 target->cr_gid = source->cr_gid;
995 target->cr_group_info = source->cr_group_info;
996 get_group_info(target->cr_group_info);
997}
998
J. Bruce Fields35bba9a2007-11-21 22:07:08 -0500999static int same_name(const char *n1, const char *n2)
J. Bruce Fields599e0a22007-07-26 17:04:54 -04001000{
NeilBrowna55370a2005-06-23 22:03:52 -07001001 return 0 == memcmp(n1, n2, HEXDIR_LEN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001002}
1003
1004static int
J. Bruce Fields599e0a22007-07-26 17:04:54 -04001005same_verf(nfs4_verifier *v1, nfs4_verifier *v2)
1006{
1007 return 0 == memcmp(v1->data, v2->data, sizeof(v1->data));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001008}
1009
1010static int
J. Bruce Fields599e0a22007-07-26 17:04:54 -04001011same_clid(clientid_t *cl1, clientid_t *cl2)
1012{
1013 return (cl1->cl_boot == cl2->cl_boot) && (cl1->cl_id == cl2->cl_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001014}
1015
1016/* XXX what about NGROUP */
1017static int
J. Bruce Fields599e0a22007-07-26 17:04:54 -04001018same_creds(struct svc_cred *cr1, struct svc_cred *cr2)
1019{
1020 return cr1->cr_uid == cr2->cr_uid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001021}
1022
J. Bruce Fields5ec7b462007-11-21 21:58:56 -05001023static void gen_clid(struct nfs4_client *clp)
1024{
1025 static u32 current_clientid = 1;
1026
Linus Torvalds1da177e2005-04-16 15:20:36 -07001027 clp->cl_clientid.cl_boot = boot_time;
1028 clp->cl_clientid.cl_id = current_clientid++;
1029}
1030
J. Bruce Fieldsdeda2fa2007-11-19 20:31:04 -05001031static void gen_confirm(struct nfs4_client *clp)
1032{
1033 static u32 i;
1034 u32 *p;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001035
Linus Torvalds1da177e2005-04-16 15:20:36 -07001036 p = (u32 *)clp->cl_confirm.data;
J. Bruce Fieldsdeda2fa2007-11-19 20:31:04 -05001037 *p++ = get_seconds();
1038 *p++ = i++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001039}
1040
Ricardo Labiagab09333c2009-09-10 12:27:34 +03001041static struct nfs4_client *create_client(struct xdr_netobj name, char *recdir,
1042 struct svc_rqst *rqstp, nfs4_verifier *verf)
1043{
1044 struct nfs4_client *clp;
1045 struct sockaddr *sa = svc_addr(rqstp);
1046 char *princ;
1047
1048 clp = alloc_client(name);
1049 if (clp == NULL)
1050 return NULL;
1051
J. Bruce Fields792c95d2010-10-12 19:55:25 -04001052 INIT_LIST_HEAD(&clp->cl_sessions);
1053
Ricardo Labiagab09333c2009-09-10 12:27:34 +03001054 princ = svc_gss_principal(rqstp);
1055 if (princ) {
1056 clp->cl_principal = kstrdup(princ, GFP_KERNEL);
1057 if (clp->cl_principal == NULL) {
1058 free_client(clp);
1059 return NULL;
1060 }
1061 }
1062
1063 memcpy(clp->cl_recdir, recdir, HEXDIR_LEN);
Benny Halevy46583e22010-05-12 00:13:29 +03001064 atomic_set(&clp->cl_refcount, 0);
J. Bruce Fields77a35692010-04-30 18:51:44 -04001065 clp->cl_cb_state = NFSD4_CB_UNKNOWN;
Ricardo Labiagab09333c2009-09-10 12:27:34 +03001066 INIT_LIST_HEAD(&clp->cl_idhash);
1067 INIT_LIST_HEAD(&clp->cl_strhash);
1068 INIT_LIST_HEAD(&clp->cl_openowners);
1069 INIT_LIST_HEAD(&clp->cl_delegations);
Ricardo Labiagab09333c2009-09-10 12:27:34 +03001070 INIT_LIST_HEAD(&clp->cl_lru);
J. Bruce Fields5ce8ba22011-01-10 16:44:41 -05001071 INIT_LIST_HEAD(&clp->cl_callbacks);
J. Bruce Fields6ff8da02010-06-04 20:04:45 -04001072 spin_lock_init(&clp->cl_lock);
J. Bruce Fieldscee277d2010-05-26 17:52:14 -04001073 INIT_WORK(&clp->cl_cb_null.cb_work, nfsd4_do_callback_rpc);
Benny Halevy07cd4902010-05-12 00:13:41 +03001074 clp->cl_time = get_seconds();
Ricardo Labiagab09333c2009-09-10 12:27:34 +03001075 clear_bit(0, &clp->cl_cb_slot_busy);
1076 rpc_init_wait_queue(&clp->cl_cb_waitq, "Backchannel slot table");
1077 copy_verf(clp, verf);
1078 rpc_copy_addr((struct sockaddr *) &clp->cl_addr, sa);
1079 clp->cl_flavor = rqstp->rq_flavor;
1080 copy_cred(&clp->cl_cred, &rqstp->rq_cred);
1081 gen_confirm(clp);
J. Bruce Fieldsedd76782010-06-14 22:26:31 -04001082 clp->cl_cb_session = NULL;
Ricardo Labiagab09333c2009-09-10 12:27:34 +03001083 return clp;
1084}
1085
J. Bruce Fields35bba9a2007-11-21 22:07:08 -05001086static int check_name(struct xdr_netobj name)
1087{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001088 if (name.len == 0)
1089 return 0;
1090 if (name.len > NFS4_OPAQUE_LIMIT) {
J. Bruce Fields2fdada02007-07-27 16:10:37 -04001091 dprintk("NFSD: check_name: name too long(%d)!\n", name.len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001092 return 0;
1093 }
1094 return 1;
1095}
1096
NeilBrownfd39ca92005-06-23 22:04:03 -07001097static void
Linus Torvalds1da177e2005-04-16 15:20:36 -07001098add_to_unconfirmed(struct nfs4_client *clp, unsigned int strhashval)
1099{
1100 unsigned int idhashval;
1101
1102 list_add(&clp->cl_strhash, &unconf_str_hashtbl[strhashval]);
1103 idhashval = clientid_hashval(clp->cl_clientid.cl_id);
1104 list_add(&clp->cl_idhash, &unconf_id_hashtbl[idhashval]);
Benny Halevy36acb662010-05-12 00:13:04 +03001105 renew_client(clp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001106}
1107
NeilBrownfd39ca92005-06-23 22:04:03 -07001108static void
Linus Torvalds1da177e2005-04-16 15:20:36 -07001109move_to_confirmed(struct nfs4_client *clp)
1110{
1111 unsigned int idhashval = clientid_hashval(clp->cl_clientid.cl_id);
1112 unsigned int strhashval;
1113
1114 dprintk("NFSD: move_to_confirm nfs4_client %p\n", clp);
Akinobu Mitaf1166292006-06-26 00:24:46 -07001115 list_move(&clp->cl_idhash, &conf_id_hashtbl[idhashval]);
NeilBrowna55370a2005-06-23 22:03:52 -07001116 strhashval = clientstr_hashval(clp->cl_recdir);
Benny Halevy328efba2010-05-12 00:12:51 +03001117 list_move(&clp->cl_strhash, &conf_str_hashtbl[strhashval]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001118 renew_client(clp);
1119}
1120
1121static struct nfs4_client *
1122find_confirmed_client(clientid_t *clid)
1123{
1124 struct nfs4_client *clp;
1125 unsigned int idhashval = clientid_hashval(clid->cl_id);
1126
1127 list_for_each_entry(clp, &conf_id_hashtbl[idhashval], cl_idhash) {
J. Bruce Fields599e0a22007-07-26 17:04:54 -04001128 if (same_clid(&clp->cl_clientid, clid))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001129 return clp;
1130 }
1131 return NULL;
1132}
1133
1134static struct nfs4_client *
1135find_unconfirmed_client(clientid_t *clid)
1136{
1137 struct nfs4_client *clp;
1138 unsigned int idhashval = clientid_hashval(clid->cl_id);
1139
1140 list_for_each_entry(clp, &unconf_id_hashtbl[idhashval], cl_idhash) {
J. Bruce Fields599e0a22007-07-26 17:04:54 -04001141 if (same_clid(&clp->cl_clientid, clid))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001142 return clp;
1143 }
1144 return NULL;
1145}
1146
J. Bruce Fields6e5f15c2010-11-24 17:17:34 -05001147static bool clp_used_exchangeid(struct nfs4_client *clp)
Andy Adamsona1bcecd2009-04-03 08:28:05 +03001148{
J. Bruce Fields6e5f15c2010-11-24 17:17:34 -05001149 return clp->cl_exchange_flags != 0;
J. Bruce Fieldse203d502010-11-24 17:30:54 -05001150}
Andy Adamsona1bcecd2009-04-03 08:28:05 +03001151
NeilBrown28ce6052005-06-23 22:03:56 -07001152static struct nfs4_client *
J. Bruce Fieldse203d502010-11-24 17:30:54 -05001153find_confirmed_client_by_str(const char *dname, unsigned int hashval)
NeilBrown28ce6052005-06-23 22:03:56 -07001154{
1155 struct nfs4_client *clp;
1156
1157 list_for_each_entry(clp, &conf_str_hashtbl[hashval], cl_strhash) {
J. Bruce Fieldse203d502010-11-24 17:30:54 -05001158 if (same_name(clp->cl_recdir, dname))
NeilBrown28ce6052005-06-23 22:03:56 -07001159 return clp;
1160 }
1161 return NULL;
1162}
1163
1164static struct nfs4_client *
J. Bruce Fieldse203d502010-11-24 17:30:54 -05001165find_unconfirmed_client_by_str(const char *dname, unsigned int hashval)
NeilBrown28ce6052005-06-23 22:03:56 -07001166{
1167 struct nfs4_client *clp;
1168
1169 list_for_each_entry(clp, &unconf_str_hashtbl[hashval], cl_strhash) {
J. Bruce Fieldse203d502010-11-24 17:30:54 -05001170 if (same_name(clp->cl_recdir, dname))
NeilBrown28ce6052005-06-23 22:03:56 -07001171 return clp;
1172 }
1173 return NULL;
1174}
1175
Takuma Umeya6f3d7722010-12-15 14:09:01 +09001176static void rpc_svcaddr2sockaddr(struct sockaddr *sa, unsigned short family, union svc_addr_u *svcaddr)
1177{
1178 switch (family) {
1179 case AF_INET:
1180 ((struct sockaddr_in *)sa)->sin_family = AF_INET;
1181 ((struct sockaddr_in *)sa)->sin_addr = svcaddr->addr;
1182 return;
1183 case AF_INET6:
1184 ((struct sockaddr_in6 *)sa)->sin6_family = AF_INET6;
1185 ((struct sockaddr_in6 *)sa)->sin6_addr = svcaddr->addr6;
1186 return;
1187 }
1188}
1189
NeilBrownfd39ca92005-06-23 22:04:03 -07001190static void
Takuma Umeya6f3d7722010-12-15 14:09:01 +09001191gen_callback(struct nfs4_client *clp, struct nfsd4_setclientid *se, struct svc_rqst *rqstp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001192{
J. Bruce Fields07263f12010-05-31 19:09:40 -04001193 struct nfs4_cb_conn *conn = &clp->cl_cb_conn;
Takuma Umeya6f3d7722010-12-15 14:09:01 +09001194 struct sockaddr *sa = svc_addr(rqstp);
1195 u32 scopeid = rpc_get_scope_id(sa);
Jeff Layton7077ecb2009-08-14 12:57:58 -04001196 unsigned short expected_family;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001197
Jeff Layton7077ecb2009-08-14 12:57:58 -04001198 /* Currently, we only support tcp and tcp6 for the callback channel */
1199 if (se->se_callback_netid_len == 3 &&
1200 !memcmp(se->se_callback_netid_val, "tcp", 3))
1201 expected_family = AF_INET;
1202 else if (se->se_callback_netid_len == 4 &&
1203 !memcmp(se->se_callback_netid_val, "tcp6", 4))
1204 expected_family = AF_INET6;
1205 else
Linus Torvalds1da177e2005-04-16 15:20:36 -07001206 goto out_err;
1207
J. Bruce Fields07263f12010-05-31 19:09:40 -04001208 conn->cb_addrlen = rpc_uaddr2sockaddr(se->se_callback_addr_val,
Jeff Laytonaa9a4ec2009-08-14 12:57:57 -04001209 se->se_callback_addr_len,
J. Bruce Fields07263f12010-05-31 19:09:40 -04001210 (struct sockaddr *)&conn->cb_addr,
1211 sizeof(conn->cb_addr));
Jeff Laytonaa9a4ec2009-08-14 12:57:57 -04001212
J. Bruce Fields07263f12010-05-31 19:09:40 -04001213 if (!conn->cb_addrlen || conn->cb_addr.ss_family != expected_family)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001214 goto out_err;
Jeff Laytonaa9a4ec2009-08-14 12:57:57 -04001215
J. Bruce Fields07263f12010-05-31 19:09:40 -04001216 if (conn->cb_addr.ss_family == AF_INET6)
1217 ((struct sockaddr_in6 *)&conn->cb_addr)->sin6_scope_id = scopeid;
Jeff Laytonfbf46652009-08-14 12:57:59 -04001218
J. Bruce Fields07263f12010-05-31 19:09:40 -04001219 conn->cb_prog = se->se_callback_prog;
1220 conn->cb_ident = se->se_callback_ident;
Takuma Umeya6f3d7722010-12-15 14:09:01 +09001221 rpc_svcaddr2sockaddr((struct sockaddr *)&conn->cb_saddr, expected_family, &rqstp->rq_daddr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001222 return;
1223out_err:
J. Bruce Fields07263f12010-05-31 19:09:40 -04001224 conn->cb_addr.ss_family = AF_UNSPEC;
1225 conn->cb_addrlen = 0;
Neil Brown849823c2005-09-13 01:25:36 -07001226 dprintk(KERN_INFO "NFSD: this client (clientid %08x/%08x) "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001227 "will not receive delegations\n",
1228 clp->cl_clientid.cl_boot, clp->cl_clientid.cl_id);
1229
Linus Torvalds1da177e2005-04-16 15:20:36 -07001230 return;
1231}
1232
Andy Adamson074fe892009-04-03 08:28:15 +03001233/*
Andy Adamson557ce262009-08-28 08:45:04 -04001234 * Cache a reply. nfsd4_check_drc_limit() has bounded the cache size.
Andy Adamson074fe892009-04-03 08:28:15 +03001235 */
1236void
1237nfsd4_store_cache_entry(struct nfsd4_compoundres *resp)
1238{
Andy Adamson557ce262009-08-28 08:45:04 -04001239 struct nfsd4_slot *slot = resp->cstate.slot;
1240 unsigned int base;
Andy Adamson074fe892009-04-03 08:28:15 +03001241
Andy Adamson557ce262009-08-28 08:45:04 -04001242 dprintk("--> %s slot %p\n", __func__, slot);
Andy Adamson074fe892009-04-03 08:28:15 +03001243
Andy Adamson557ce262009-08-28 08:45:04 -04001244 slot->sl_opcnt = resp->opcnt;
1245 slot->sl_status = resp->cstate.status;
Andy Adamsonbf864a32009-04-03 08:28:35 +03001246
1247 if (nfsd4_not_cached(resp)) {
Andy Adamson557ce262009-08-28 08:45:04 -04001248 slot->sl_datalen = 0;
Andy Adamsonbf864a32009-04-03 08:28:35 +03001249 return;
1250 }
Andy Adamson557ce262009-08-28 08:45:04 -04001251 slot->sl_datalen = (char *)resp->p - (char *)resp->cstate.datap;
1252 base = (char *)resp->cstate.datap -
1253 (char *)resp->xbuf->head[0].iov_base;
1254 if (read_bytes_from_xdr_buf(resp->xbuf, base, slot->sl_data,
1255 slot->sl_datalen))
1256 WARN("%s: sessions DRC could not cache compound\n", __func__);
1257 return;
Andy Adamson074fe892009-04-03 08:28:15 +03001258}
1259
1260/*
Andy Adamsonabfabf82009-07-23 19:02:18 -04001261 * Encode the replay sequence operation from the slot values.
1262 * If cachethis is FALSE encode the uncached rep error on the next
1263 * operation which sets resp->p and increments resp->opcnt for
1264 * nfs4svc_encode_compoundres.
1265 *
Andy Adamson074fe892009-04-03 08:28:15 +03001266 */
Andy Adamsonabfabf82009-07-23 19:02:18 -04001267static __be32
1268nfsd4_enc_sequence_replay(struct nfsd4_compoundargs *args,
1269 struct nfsd4_compoundres *resp)
Andy Adamson074fe892009-04-03 08:28:15 +03001270{
Andy Adamsonabfabf82009-07-23 19:02:18 -04001271 struct nfsd4_op *op;
1272 struct nfsd4_slot *slot = resp->cstate.slot;
Andy Adamson074fe892009-04-03 08:28:15 +03001273
Andy Adamsonabfabf82009-07-23 19:02:18 -04001274 dprintk("--> %s resp->opcnt %d cachethis %u \n", __func__,
Andy Adamson557ce262009-08-28 08:45:04 -04001275 resp->opcnt, resp->cstate.slot->sl_cachethis);
Andy Adamsonabfabf82009-07-23 19:02:18 -04001276
1277 /* Encode the replayed sequence operation */
1278 op = &args->ops[resp->opcnt - 1];
1279 nfsd4_encode_operation(resp, op);
1280
1281 /* Return nfserr_retry_uncached_rep in next operation. */
Andy Adamson557ce262009-08-28 08:45:04 -04001282 if (args->opcnt > 1 && slot->sl_cachethis == 0) {
Andy Adamsonabfabf82009-07-23 19:02:18 -04001283 op = &args->ops[resp->opcnt++];
1284 op->status = nfserr_retry_uncached_rep;
1285 nfsd4_encode_operation(resp, op);
Andy Adamson074fe892009-04-03 08:28:15 +03001286 }
Andy Adamsonabfabf82009-07-23 19:02:18 -04001287 return op->status;
Andy Adamson074fe892009-04-03 08:28:15 +03001288}
1289
1290/*
Andy Adamson557ce262009-08-28 08:45:04 -04001291 * The sequence operation is not cached because we can use the slot and
1292 * session values.
Andy Adamson074fe892009-04-03 08:28:15 +03001293 */
1294__be32
Andy Adamsonbf864a32009-04-03 08:28:35 +03001295nfsd4_replay_cache_entry(struct nfsd4_compoundres *resp,
1296 struct nfsd4_sequence *seq)
Andy Adamson074fe892009-04-03 08:28:15 +03001297{
Andy Adamson557ce262009-08-28 08:45:04 -04001298 struct nfsd4_slot *slot = resp->cstate.slot;
Andy Adamson074fe892009-04-03 08:28:15 +03001299 __be32 status;
1300
Andy Adamson557ce262009-08-28 08:45:04 -04001301 dprintk("--> %s slot %p\n", __func__, slot);
Andy Adamson074fe892009-04-03 08:28:15 +03001302
Andy Adamsonabfabf82009-07-23 19:02:18 -04001303 /* Either returns 0 or nfserr_retry_uncached */
1304 status = nfsd4_enc_sequence_replay(resp->rqstp->rq_argp, resp);
1305 if (status == nfserr_retry_uncached_rep)
1306 return status;
Andy Adamson074fe892009-04-03 08:28:15 +03001307
Andy Adamson557ce262009-08-28 08:45:04 -04001308 /* The sequence operation has been encoded, cstate->datap set. */
1309 memcpy(resp->cstate.datap, slot->sl_data, slot->sl_datalen);
Andy Adamson074fe892009-04-03 08:28:15 +03001310
Andy Adamson557ce262009-08-28 08:45:04 -04001311 resp->opcnt = slot->sl_opcnt;
1312 resp->p = resp->cstate.datap + XDR_QUADLEN(slot->sl_datalen);
1313 status = slot->sl_status;
Andy Adamson074fe892009-04-03 08:28:15 +03001314
1315 return status;
1316}
1317
Andy Adamson0733d212009-04-03 08:28:01 +03001318/*
1319 * Set the exchange_id flags returned by the server.
1320 */
1321static void
1322nfsd4_set_ex_flags(struct nfs4_client *new, struct nfsd4_exchange_id *clid)
1323{
1324 /* pNFS is not supported */
1325 new->cl_exchange_flags |= EXCHGID4_FLAG_USE_NON_PNFS;
1326
1327 /* Referrals are supported, Migration is not. */
1328 new->cl_exchange_flags |= EXCHGID4_FLAG_SUPP_MOVED_REFER;
1329
1330 /* set the wire flags to return to client. */
1331 clid->flags = new->cl_exchange_flags;
1332}
1333
Al Virob37ad282006-10-19 23:28:59 -07001334__be32
Andy Adamson069b6ad2009-04-03 08:27:58 +03001335nfsd4_exchange_id(struct svc_rqst *rqstp,
1336 struct nfsd4_compound_state *cstate,
1337 struct nfsd4_exchange_id *exid)
1338{
Andy Adamson0733d212009-04-03 08:28:01 +03001339 struct nfs4_client *unconf, *conf, *new;
1340 int status;
1341 unsigned int strhashval;
1342 char dname[HEXDIR_LEN];
Jeff Layton363168b2009-08-14 12:57:56 -04001343 char addr_str[INET6_ADDRSTRLEN];
Andy Adamson0733d212009-04-03 08:28:01 +03001344 nfs4_verifier verf = exid->verifier;
Jeff Layton363168b2009-08-14 12:57:56 -04001345 struct sockaddr *sa = svc_addr(rqstp);
Andy Adamson0733d212009-04-03 08:28:01 +03001346
Jeff Layton363168b2009-08-14 12:57:56 -04001347 rpc_ntop(sa, addr_str, sizeof(addr_str));
Andy Adamson0733d212009-04-03 08:28:01 +03001348 dprintk("%s rqstp=%p exid=%p clname.len=%u clname.data=%p "
Jeff Layton363168b2009-08-14 12:57:56 -04001349 "ip_addr=%s flags %x, spa_how %d\n",
Andy Adamson0733d212009-04-03 08:28:01 +03001350 __func__, rqstp, exid, exid->clname.len, exid->clname.data,
Jeff Layton363168b2009-08-14 12:57:56 -04001351 addr_str, exid->flags, exid->spa_how);
Andy Adamson0733d212009-04-03 08:28:01 +03001352
1353 if (!check_name(exid->clname) || (exid->flags & ~EXCHGID4_FLAG_MASK_A))
1354 return nfserr_inval;
1355
1356 /* Currently only support SP4_NONE */
1357 switch (exid->spa_how) {
1358 case SP4_NONE:
1359 break;
1360 case SP4_SSV:
J. Bruce Fields044bc1d2010-11-12 14:36:06 -05001361 return nfserr_serverfault;
Andy Adamson0733d212009-04-03 08:28:01 +03001362 default:
1363 BUG(); /* checked by xdr code */
1364 case SP4_MACH_CRED:
1365 return nfserr_serverfault; /* no excuse :-/ */
1366 }
1367
1368 status = nfs4_make_rec_clidname(dname, &exid->clname);
1369
1370 if (status)
1371 goto error;
1372
1373 strhashval = clientstr_hashval(dname);
1374
1375 nfs4_lock_state();
1376 status = nfs_ok;
1377
J. Bruce Fieldse203d502010-11-24 17:30:54 -05001378 conf = find_confirmed_client_by_str(dname, strhashval);
Andy Adamson0733d212009-04-03 08:28:01 +03001379 if (conf) {
J. Bruce Fieldse203d502010-11-24 17:30:54 -05001380 if (!clp_used_exchangeid(conf)) {
1381 status = nfserr_clid_inuse; /* XXX: ? */
1382 goto out;
1383 }
Andy Adamson0733d212009-04-03 08:28:01 +03001384 if (!same_verf(&verf, &conf->cl_verifier)) {
1385 /* 18.35.4 case 8 */
1386 if (exid->flags & EXCHGID4_FLAG_UPD_CONFIRMED_REC_A) {
1387 status = nfserr_not_same;
1388 goto out;
1389 }
1390 /* Client reboot: destroy old state */
1391 expire_client(conf);
1392 goto out_new;
1393 }
1394 if (!same_creds(&conf->cl_cred, &rqstp->rq_cred)) {
1395 /* 18.35.4 case 9 */
1396 if (exid->flags & EXCHGID4_FLAG_UPD_CONFIRMED_REC_A) {
1397 status = nfserr_perm;
1398 goto out;
1399 }
1400 expire_client(conf);
1401 goto out_new;
1402 }
Andy Adamson0733d212009-04-03 08:28:01 +03001403 /*
1404 * Set bit when the owner id and verifier map to an already
1405 * confirmed client id (18.35.3).
1406 */
1407 exid->flags |= EXCHGID4_FLAG_CONFIRMED_R;
1408
1409 /*
1410 * Falling into 18.35.4 case 2, possible router replay.
1411 * Leave confirmed record intact and return same result.
1412 */
1413 copy_verf(conf, &verf);
1414 new = conf;
1415 goto out_copy;
Mike Sager6ddbbbf2009-06-16 04:20:47 +03001416 }
1417
1418 /* 18.35.4 case 7 */
1419 if (exid->flags & EXCHGID4_FLAG_UPD_CONFIRMED_REC_A) {
1420 status = nfserr_noent;
1421 goto out;
Andy Adamson0733d212009-04-03 08:28:01 +03001422 }
1423
J. Bruce Fieldse203d502010-11-24 17:30:54 -05001424 unconf = find_unconfirmed_client_by_str(dname, strhashval);
Andy Adamson0733d212009-04-03 08:28:01 +03001425 if (unconf) {
1426 /*
1427 * Possible retry or client restart. Per 18.35.4 case 4,
1428 * a new unconfirmed record should be generated regardless
1429 * of whether any properties have changed.
1430 */
1431 expire_client(unconf);
1432 }
1433
1434out_new:
1435 /* Normal case */
Ricardo Labiagab09333c2009-09-10 12:27:34 +03001436 new = create_client(exid->clname, dname, rqstp, &verf);
Andy Adamson0733d212009-04-03 08:28:01 +03001437 if (new == NULL) {
J. Bruce Fields47310302010-06-22 16:17:12 -04001438 status = nfserr_jukebox;
Andy Adamson0733d212009-04-03 08:28:01 +03001439 goto out;
1440 }
1441
Andy Adamson0733d212009-04-03 08:28:01 +03001442 gen_clid(new);
Andy Adamson0733d212009-04-03 08:28:01 +03001443 add_to_unconfirmed(new, strhashval);
1444out_copy:
1445 exid->clientid.cl_boot = new->cl_clientid.cl_boot;
1446 exid->clientid.cl_id = new->cl_clientid.cl_id;
1447
Andy Adamson38eb76a2009-04-03 08:28:32 +03001448 exid->seqid = 1;
Andy Adamson0733d212009-04-03 08:28:01 +03001449 nfsd4_set_ex_flags(new, exid);
1450
1451 dprintk("nfsd4_exchange_id seqid %d flags %x\n",
Andy Adamson49557cc2009-07-23 19:02:16 -04001452 new->cl_cs_slot.sl_seqid, new->cl_exchange_flags);
Andy Adamson0733d212009-04-03 08:28:01 +03001453 status = nfs_ok;
1454
1455out:
1456 nfs4_unlock_state();
1457error:
1458 dprintk("nfsd4_exchange_id returns %d\n", ntohl(status));
1459 return status;
Andy Adamson069b6ad2009-04-03 08:27:58 +03001460}
1461
Benny Halevyb85d4c02009-04-03 08:28:08 +03001462static int
Andy Adamson88e588d2009-07-23 19:02:15 -04001463check_slot_seqid(u32 seqid, u32 slot_seqid, int slot_inuse)
Benny Halevyb85d4c02009-04-03 08:28:08 +03001464{
Andy Adamson88e588d2009-07-23 19:02:15 -04001465 dprintk("%s enter. seqid %d slot_seqid %d\n", __func__, seqid,
1466 slot_seqid);
Benny Halevyb85d4c02009-04-03 08:28:08 +03001467
1468 /* The slot is in use, and no response has been sent. */
Andy Adamson88e588d2009-07-23 19:02:15 -04001469 if (slot_inuse) {
1470 if (seqid == slot_seqid)
Benny Halevyb85d4c02009-04-03 08:28:08 +03001471 return nfserr_jukebox;
1472 else
1473 return nfserr_seq_misordered;
1474 }
1475 /* Normal */
Andy Adamson88e588d2009-07-23 19:02:15 -04001476 if (likely(seqid == slot_seqid + 1))
Benny Halevyb85d4c02009-04-03 08:28:08 +03001477 return nfs_ok;
1478 /* Replay */
Andy Adamson88e588d2009-07-23 19:02:15 -04001479 if (seqid == slot_seqid)
Benny Halevyb85d4c02009-04-03 08:28:08 +03001480 return nfserr_replay_cache;
1481 /* Wraparound */
Andy Adamson88e588d2009-07-23 19:02:15 -04001482 if (seqid == 1 && (slot_seqid + 1) == 0)
Benny Halevyb85d4c02009-04-03 08:28:08 +03001483 return nfs_ok;
1484 /* Misordered replay or misordered new request */
1485 return nfserr_seq_misordered;
1486}
1487
Andy Adamson49557cc2009-07-23 19:02:16 -04001488/*
1489 * Cache the create session result into the create session single DRC
1490 * slot cache by saving the xdr structure. sl_seqid has been set.
1491 * Do this for solo or embedded create session operations.
1492 */
1493static void
1494nfsd4_cache_create_session(struct nfsd4_create_session *cr_ses,
1495 struct nfsd4_clid_slot *slot, int nfserr)
1496{
1497 slot->sl_status = nfserr;
1498 memcpy(&slot->sl_cr_ses, cr_ses, sizeof(*cr_ses));
1499}
1500
1501static __be32
1502nfsd4_replay_create_session(struct nfsd4_create_session *cr_ses,
1503 struct nfsd4_clid_slot *slot)
1504{
1505 memcpy(cr_ses, &slot->sl_cr_ses, sizeof(*cr_ses));
1506 return slot->sl_status;
1507}
1508
Mi Jinlong1b74c252011-07-14 14:50:17 +08001509#define NFSD_MIN_REQ_HDR_SEQ_SZ ((\
1510 2 * 2 + /* credential,verifier: AUTH_NULL, length 0 */ \
1511 1 + /* MIN tag is length with zero, only length */ \
1512 3 + /* version, opcount, opcode */ \
1513 XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + \
1514 /* seqid, slotID, slotID, cache */ \
1515 4 ) * sizeof(__be32))
1516
1517#define NFSD_MIN_RESP_HDR_SEQ_SZ ((\
1518 2 + /* verifier: AUTH_NULL, length 0 */\
1519 1 + /* status */ \
1520 1 + /* MIN tag is length with zero, only length */ \
1521 3 + /* opcount, opcode, opstatus*/ \
1522 XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + \
1523 /* seqid, slotID, slotID, slotID, status */ \
1524 5 ) * sizeof(__be32))
1525
1526static __be32 check_forechannel_attrs(struct nfsd4_channel_attrs fchannel)
1527{
1528 return fchannel.maxreq_sz < NFSD_MIN_REQ_HDR_SEQ_SZ
1529 || fchannel.maxresp_sz < NFSD_MIN_RESP_HDR_SEQ_SZ;
1530}
1531
Andy Adamson069b6ad2009-04-03 08:27:58 +03001532__be32
1533nfsd4_create_session(struct svc_rqst *rqstp,
1534 struct nfsd4_compound_state *cstate,
1535 struct nfsd4_create_session *cr_ses)
1536{
Jeff Layton363168b2009-08-14 12:57:56 -04001537 struct sockaddr *sa = svc_addr(rqstp);
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001538 struct nfs4_client *conf, *unconf;
J. Bruce Fieldsac7c46f2010-06-14 19:01:57 -04001539 struct nfsd4_session *new;
Andy Adamson49557cc2009-07-23 19:02:16 -04001540 struct nfsd4_clid_slot *cs_slot = NULL;
J. Bruce Fields86c3e162010-10-02 17:04:00 -04001541 bool confirm_me = false;
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001542 int status = 0;
1543
Mi Jinlonga62573d2011-03-23 17:57:07 +08001544 if (cr_ses->flags & ~SESSION4_FLAG_MASK_A)
1545 return nfserr_inval;
1546
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001547 nfs4_lock_state();
1548 unconf = find_unconfirmed_client(&cr_ses->clientid);
1549 conf = find_confirmed_client(&cr_ses->clientid);
1550
1551 if (conf) {
Andy Adamson49557cc2009-07-23 19:02:16 -04001552 cs_slot = &conf->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 == nfserr_replay_cache) {
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001555 dprintk("Got a create_session replay! seqid= %d\n",
Andy Adamson49557cc2009-07-23 19:02:16 -04001556 cs_slot->sl_seqid);
Andy Adamson38eb76a2009-04-03 08:28:32 +03001557 /* Return the cached reply status */
Andy Adamson49557cc2009-07-23 19:02:16 -04001558 status = nfsd4_replay_create_session(cr_ses, cs_slot);
Andy Adamson38eb76a2009-04-03 08:28:32 +03001559 goto out;
Andy Adamson49557cc2009-07-23 19:02:16 -04001560 } else if (cr_ses->seqid != cs_slot->sl_seqid + 1) {
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001561 status = nfserr_seq_misordered;
1562 dprintk("Sequence misordered!\n");
1563 dprintk("Expected seqid= %d but got seqid= %d\n",
Andy Adamson49557cc2009-07-23 19:02:16 -04001564 cs_slot->sl_seqid, cr_ses->seqid);
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001565 goto out;
1566 }
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001567 } else if (unconf) {
1568 if (!same_creds(&unconf->cl_cred, &rqstp->rq_cred) ||
Jeff Layton363168b2009-08-14 12:57:56 -04001569 !rpc_cmp_addr(sa, (struct sockaddr *) &unconf->cl_addr)) {
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001570 status = nfserr_clid_inuse;
1571 goto out;
1572 }
1573
Andy Adamson49557cc2009-07-23 19:02:16 -04001574 cs_slot = &unconf->cl_cs_slot;
1575 status = check_slot_seqid(cr_ses->seqid, cs_slot->sl_seqid, 0);
Andy Adamson38eb76a2009-04-03 08:28:32 +03001576 if (status) {
1577 /* an unconfirmed replay returns misordered */
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001578 status = nfserr_seq_misordered;
J. Bruce Fieldscd5b8142010-10-02 17:03:35 -04001579 goto out;
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001580 }
1581
J. Bruce Fields86c3e162010-10-02 17:04:00 -04001582 confirm_me = true;
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001583 conf = unconf;
1584 } else {
1585 status = nfserr_stale_clientid;
1586 goto out;
1587 }
1588
J. Bruce Fields408b79b2010-04-15 15:11:09 -04001589 /*
J. Bruce Fields8323c3b2010-10-19 19:36:51 -04001590 * XXX: we should probably set this at creation time, and check
1591 * for consistent minorversion use throughout:
1592 */
1593 conf->cl_minorversion = 1;
1594 /*
J. Bruce Fields408b79b2010-04-15 15:11:09 -04001595 * We do not support RDMA or persistent sessions
1596 */
1597 cr_ses->flags &= ~SESSION4_PERSIST;
1598 cr_ses->flags &= ~SESSION4_RDMA;
1599
Mi Jinlong1b74c252011-07-14 14:50:17 +08001600 status = nfserr_toosmall;
1601 if (check_forechannel_attrs(cr_ses->fore_channel))
1602 goto out;
1603
J. Bruce Fieldsac7c46f2010-06-14 19:01:57 -04001604 status = nfserr_jukebox;
1605 new = alloc_init_session(rqstp, conf, cr_ses);
1606 if (!new)
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001607 goto out;
J. Bruce Fieldsac7c46f2010-06-14 19:01:57 -04001608 status = nfs_ok;
1609 memcpy(cr_ses->sessionid.data, new->se_sessionid.data,
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001610 NFS4_MAX_SESSIONID_LEN);
Mi Jinlong12050652010-11-11 18:03:40 +08001611 memcpy(&cr_ses->fore_channel, &new->se_fchannel,
1612 sizeof(struct nfsd4_channel_attrs));
J. Bruce Fields86c3e162010-10-02 17:04:00 -04001613 cs_slot->sl_seqid++;
Andy Adamson49557cc2009-07-23 19:02:16 -04001614 cr_ses->seqid = cs_slot->sl_seqid;
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001615
Andy Adamson49557cc2009-07-23 19:02:16 -04001616 /* cache solo and embedded create sessions under the state lock */
1617 nfsd4_cache_create_session(cr_ses, cs_slot, status);
J. Bruce Fields86c3e162010-10-02 17:04:00 -04001618 if (confirm_me)
1619 move_to_confirmed(conf);
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001620out:
1621 nfs4_unlock_state();
1622 dprintk("%s returns %d\n", __func__, ntohl(status));
1623 return status;
Andy Adamson069b6ad2009-04-03 08:27:58 +03001624}
1625
J. Bruce Fields57716352010-04-21 12:27:19 -04001626static bool nfsd4_last_compound_op(struct svc_rqst *rqstp)
1627{
1628 struct nfsd4_compoundres *resp = rqstp->rq_resp;
1629 struct nfsd4_compoundargs *argp = rqstp->rq_argp;
1630
1631 return argp->opcnt == resp->opcnt;
1632}
1633
J. Bruce Fields1d1bc8f2010-10-04 23:12:59 -04001634static __be32 nfsd4_map_bcts_dir(u32 *dir)
1635{
1636 switch (*dir) {
1637 case NFS4_CDFC4_FORE:
1638 case NFS4_CDFC4_BACK:
1639 return nfs_ok;
1640 case NFS4_CDFC4_FORE_OR_BOTH:
1641 case NFS4_CDFC4_BACK_OR_BOTH:
1642 *dir = NFS4_CDFC4_BOTH;
1643 return nfs_ok;
1644 };
1645 return nfserr_inval;
1646}
1647
1648__be32 nfsd4_bind_conn_to_session(struct svc_rqst *rqstp,
1649 struct nfsd4_compound_state *cstate,
1650 struct nfsd4_bind_conn_to_session *bcts)
1651{
1652 __be32 status;
1653
1654 if (!nfsd4_last_compound_op(rqstp))
1655 return nfserr_not_only_op;
1656 spin_lock(&client_lock);
1657 cstate->session = find_in_sessionid_hashtbl(&bcts->sessionid);
1658 /* Sorta weird: we only need the refcnt'ing because new_conn acquires
1659 * client_lock iself: */
1660 if (cstate->session) {
1661 nfsd4_get_session(cstate->session);
1662 atomic_inc(&cstate->session->se_client->cl_refcount);
1663 }
1664 spin_unlock(&client_lock);
1665 if (!cstate->session)
1666 return nfserr_badsession;
1667
1668 status = nfsd4_map_bcts_dir(&bcts->dir);
Bryan Schumaker1db2b9d2011-04-27 15:47:15 -04001669 if (!status)
1670 nfsd4_new_conn(rqstp, cstate->session, bcts->dir);
1671 return status;
J. Bruce Fields1d1bc8f2010-10-04 23:12:59 -04001672}
1673
J. Bruce Fields5d4cec22010-05-01 12:56:06 -04001674static bool nfsd4_compound_in_session(struct nfsd4_session *session, struct nfs4_sessionid *sid)
1675{
1676 if (!session)
1677 return 0;
1678 return !memcmp(sid, &session->se_sessionid, sizeof(*sid));
1679}
1680
Andy Adamson069b6ad2009-04-03 08:27:58 +03001681__be32
1682nfsd4_destroy_session(struct svc_rqst *r,
1683 struct nfsd4_compound_state *cstate,
1684 struct nfsd4_destroy_session *sessionid)
1685{
Benny Halevye10e0cf2009-04-03 08:28:38 +03001686 struct nfsd4_session *ses;
1687 u32 status = nfserr_badsession;
1688
1689 /* Notes:
1690 * - The confirmed nfs4_client->cl_sessionid holds destroyed sessinid
1691 * - Should we return nfserr_back_chan_busy if waiting for
1692 * callbacks on to-be-destroyed session?
1693 * - Do we need to clear any callback info from previous session?
1694 */
1695
J. Bruce Fields5d4cec22010-05-01 12:56:06 -04001696 if (nfsd4_compound_in_session(cstate->session, &sessionid->sessionid)) {
J. Bruce Fields57716352010-04-21 12:27:19 -04001697 if (!nfsd4_last_compound_op(r))
1698 return nfserr_not_only_op;
1699 }
Benny Halevye10e0cf2009-04-03 08:28:38 +03001700 dump_sessionid(__func__, &sessionid->sessionid);
Benny Halevy9089f1b2010-05-12 00:12:26 +03001701 spin_lock(&client_lock);
Benny Halevye10e0cf2009-04-03 08:28:38 +03001702 ses = find_in_sessionid_hashtbl(&sessionid->sessionid);
1703 if (!ses) {
Benny Halevy9089f1b2010-05-12 00:12:26 +03001704 spin_unlock(&client_lock);
Benny Halevye10e0cf2009-04-03 08:28:38 +03001705 goto out;
1706 }
1707
1708 unhash_session(ses);
Benny Halevy9089f1b2010-05-12 00:12:26 +03001709 spin_unlock(&client_lock);
Benny Halevye10e0cf2009-04-03 08:28:38 +03001710
Benny Halevyab707e152010-05-12 00:14:06 +03001711 nfs4_lock_state();
J. Bruce Fields84f5f7c2010-12-09 15:52:19 -05001712 nfsd4_probe_callback_sync(ses->se_client);
Benny Halevyab707e152010-05-12 00:14:06 +03001713 nfs4_unlock_state();
J. Bruce Fields19cf5c02010-06-06 18:37:16 -04001714
1715 nfsd4_del_conns(ses);
1716
Benny Halevye10e0cf2009-04-03 08:28:38 +03001717 nfsd4_put_session(ses);
1718 status = nfs_ok;
1719out:
1720 dprintk("%s returns %d\n", __func__, ntohl(status));
1721 return status;
Andy Adamson069b6ad2009-04-03 08:27:58 +03001722}
1723
J. Bruce Fieldsa663bdd2010-10-21 17:17:31 -04001724static struct nfsd4_conn *__nfsd4_find_conn(struct svc_xprt *xpt, struct nfsd4_session *s)
J. Bruce Fields328ead22010-09-29 16:11:06 -04001725{
1726 struct nfsd4_conn *c;
1727
1728 list_for_each_entry(c, &s->se_conns, cn_persession) {
J. Bruce Fieldsa663bdd2010-10-21 17:17:31 -04001729 if (c->cn_xprt == xpt) {
J. Bruce Fields328ead22010-09-29 16:11:06 -04001730 return c;
1731 }
1732 }
1733 return NULL;
1734}
1735
J. Bruce Fieldsa663bdd2010-10-21 17:17:31 -04001736static void nfsd4_sequence_check_conn(struct nfsd4_conn *new, struct nfsd4_session *ses)
J. Bruce Fields328ead22010-09-29 16:11:06 -04001737{
1738 struct nfs4_client *clp = ses->se_client;
J. Bruce Fieldsa663bdd2010-10-21 17:17:31 -04001739 struct nfsd4_conn *c;
J. Bruce Fields21b75b02010-10-26 10:07:17 -04001740 int ret;
J. Bruce Fields328ead22010-09-29 16:11:06 -04001741
1742 spin_lock(&clp->cl_lock);
J. Bruce Fieldsa663bdd2010-10-21 17:17:31 -04001743 c = __nfsd4_find_conn(new->cn_xprt, ses);
J. Bruce Fields328ead22010-09-29 16:11:06 -04001744 if (c) {
1745 spin_unlock(&clp->cl_lock);
1746 free_conn(new);
1747 return;
1748 }
1749 __nfsd4_hash_conn(new, ses);
1750 spin_unlock(&clp->cl_lock);
J. Bruce Fields21b75b02010-10-26 10:07:17 -04001751 ret = nfsd4_register_conn(new);
1752 if (ret)
1753 /* oops; xprt is already down: */
1754 nfsd4_conn_lost(&new->cn_xpt_user);
J. Bruce Fields328ead22010-09-29 16:11:06 -04001755 return;
1756}
1757
Mi Jinlong868b89c2011-04-27 09:09:58 +08001758static bool nfsd4_session_too_many_ops(struct svc_rqst *rqstp, struct nfsd4_session *session)
1759{
1760 struct nfsd4_compoundargs *args = rqstp->rq_argp;
1761
1762 return args->opcnt > session->se_fchannel.maxops;
1763}
1764
Mi Jinlongae82a8d2011-07-14 14:56:02 +08001765static bool nfsd4_request_too_big(struct svc_rqst *rqstp,
1766 struct nfsd4_session *session)
1767{
1768 struct xdr_buf *xb = &rqstp->rq_arg;
1769
1770 return xb->len > session->se_fchannel.maxreq_sz;
1771}
1772
Andy Adamson069b6ad2009-04-03 08:27:58 +03001773__be32
Benny Halevyb85d4c02009-04-03 08:28:08 +03001774nfsd4_sequence(struct svc_rqst *rqstp,
Andy Adamson069b6ad2009-04-03 08:27:58 +03001775 struct nfsd4_compound_state *cstate,
1776 struct nfsd4_sequence *seq)
1777{
Andy Adamsonf9bb94c42009-04-03 08:28:12 +03001778 struct nfsd4_compoundres *resp = rqstp->rq_resp;
Benny Halevyb85d4c02009-04-03 08:28:08 +03001779 struct nfsd4_session *session;
1780 struct nfsd4_slot *slot;
J. Bruce Fieldsa663bdd2010-10-21 17:17:31 -04001781 struct nfsd4_conn *conn;
Benny Halevyb85d4c02009-04-03 08:28:08 +03001782 int status;
1783
Andy Adamsonf9bb94c42009-04-03 08:28:12 +03001784 if (resp->opcnt != 1)
1785 return nfserr_sequence_pos;
1786
J. Bruce Fieldsa663bdd2010-10-21 17:17:31 -04001787 /*
1788 * Will be either used or freed by nfsd4_sequence_check_conn
1789 * below.
1790 */
1791 conn = alloc_conn(rqstp, NFS4_CDFC4_FORE);
1792 if (!conn)
1793 return nfserr_jukebox;
1794
Benny Halevy9089f1b2010-05-12 00:12:26 +03001795 spin_lock(&client_lock);
Benny Halevyb85d4c02009-04-03 08:28:08 +03001796 status = nfserr_badsession;
1797 session = find_in_sessionid_hashtbl(&seq->sessionid);
1798 if (!session)
1799 goto out;
1800
Mi Jinlong868b89c2011-04-27 09:09:58 +08001801 status = nfserr_too_many_ops;
1802 if (nfsd4_session_too_many_ops(rqstp, session))
1803 goto out;
1804
Mi Jinlongae82a8d2011-07-14 14:56:02 +08001805 status = nfserr_req_too_big;
1806 if (nfsd4_request_too_big(rqstp, session))
1807 goto out;
1808
Benny Halevyb85d4c02009-04-03 08:28:08 +03001809 status = nfserr_badslot;
Alexandros Batsakis6c18ba92009-06-16 04:19:13 +03001810 if (seq->slotid >= session->se_fchannel.maxreqs)
Benny Halevyb85d4c02009-04-03 08:28:08 +03001811 goto out;
1812
Andy Adamson557ce262009-08-28 08:45:04 -04001813 slot = session->se_slots[seq->slotid];
Benny Halevyb85d4c02009-04-03 08:28:08 +03001814 dprintk("%s: slotid %d\n", __func__, seq->slotid);
1815
Andy Adamsona8dfdae2009-08-28 08:45:02 -04001816 /* We do not negotiate the number of slots yet, so set the
1817 * maxslots to the session maxreqs which is used to encode
1818 * sr_highest_slotid and the sr_target_slot id to maxslots */
1819 seq->maxslots = session->se_fchannel.maxreqs;
1820
Andy Adamson88e588d2009-07-23 19:02:15 -04001821 status = check_slot_seqid(seq->seqid, slot->sl_seqid, slot->sl_inuse);
Benny Halevyb85d4c02009-04-03 08:28:08 +03001822 if (status == nfserr_replay_cache) {
1823 cstate->slot = slot;
1824 cstate->session = session;
Andy Adamsonda3846a2009-04-03 08:28:22 +03001825 /* Return the cached reply status and set cstate->status
Andy Adamson557ce262009-08-28 08:45:04 -04001826 * for nfsd4_proc_compound processing */
Andy Adamsonbf864a32009-04-03 08:28:35 +03001827 status = nfsd4_replay_cache_entry(resp, seq);
Andy Adamsonda3846a2009-04-03 08:28:22 +03001828 cstate->status = nfserr_replay_cache;
Benny Halevyaaf84eb2009-08-20 03:21:56 +03001829 goto out;
Benny Halevyb85d4c02009-04-03 08:28:08 +03001830 }
1831 if (status)
1832 goto out;
1833
J. Bruce Fieldsa663bdd2010-10-21 17:17:31 -04001834 nfsd4_sequence_check_conn(conn, session);
1835 conn = NULL;
J. Bruce Fields328ead22010-09-29 16:11:06 -04001836
Benny Halevyb85d4c02009-04-03 08:28:08 +03001837 /* Success! bump slot seqid */
1838 slot->sl_inuse = true;
1839 slot->sl_seqid = seq->seqid;
Andy Adamson557ce262009-08-28 08:45:04 -04001840 slot->sl_cachethis = seq->cachethis;
Benny Halevyb85d4c02009-04-03 08:28:08 +03001841
1842 cstate->slot = slot;
1843 cstate->session = session;
1844
Benny Halevyb85d4c02009-04-03 08:28:08 +03001845out:
J. Bruce Fields26c0c752010-04-24 15:35:43 -04001846 /* Hold a session reference until done processing the compound. */
Benny Halevyaaf84eb2009-08-20 03:21:56 +03001847 if (cstate->session) {
J. Bruce Fields0d7bb712010-11-18 08:30:33 -05001848 struct nfs4_client *clp = session->se_client;
1849
Benny Halevy36acb662010-05-12 00:13:04 +03001850 nfsd4_get_session(cstate->session);
J. Bruce Fields0d7bb712010-11-18 08:30:33 -05001851 atomic_inc(&clp->cl_refcount);
1852 if (clp->cl_cb_state == NFSD4_CB_DOWN)
1853 seq->status_flags |= SEQ4_STATUS_CB_PATH_DOWN;
Benny Halevyaaf84eb2009-08-20 03:21:56 +03001854 }
J. Bruce Fieldsa663bdd2010-10-21 17:17:31 -04001855 kfree(conn);
Benny Halevy36acb662010-05-12 00:13:04 +03001856 spin_unlock(&client_lock);
Benny Halevyb85d4c02009-04-03 08:28:08 +03001857 dprintk("%s: return %d\n", __func__, ntohl(status));
1858 return status;
Andy Adamson069b6ad2009-04-03 08:27:58 +03001859}
1860
1861__be32
J. Bruce Fields4dc6ec02010-04-19 15:11:28 -04001862nfsd4_reclaim_complete(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_reclaim_complete *rc)
1863{
Mi Jinlongbcecf1c2011-04-27 09:14:30 +08001864 int status = 0;
1865
J. Bruce Fields4dc6ec02010-04-19 15:11:28 -04001866 if (rc->rca_one_fs) {
1867 if (!cstate->current_fh.fh_dentry)
1868 return nfserr_nofilehandle;
1869 /*
1870 * We don't take advantage of the rca_one_fs case.
1871 * That's OK, it's optional, we can safely ignore it.
1872 */
1873 return nfs_ok;
1874 }
Mi Jinlongbcecf1c2011-04-27 09:14:30 +08001875
J. Bruce Fields4dc6ec02010-04-19 15:11:28 -04001876 nfs4_lock_state();
Mi Jinlongbcecf1c2011-04-27 09:14:30 +08001877 status = nfserr_complete_already;
1878 if (cstate->session->se_client->cl_firststate)
1879 goto out;
1880
1881 status = nfserr_stale_clientid;
1882 if (is_client_expired(cstate->session->se_client))
J. Bruce Fields4dc6ec02010-04-19 15:11:28 -04001883 /*
1884 * The following error isn't really legal.
1885 * But we only get here if the client just explicitly
1886 * destroyed the client. Surely it no longer cares what
1887 * error it gets back on an operation for the dead
1888 * client.
1889 */
Mi Jinlongbcecf1c2011-04-27 09:14:30 +08001890 goto out;
1891
1892 status = nfs_ok;
J. Bruce Fields4dc6ec02010-04-19 15:11:28 -04001893 nfsd4_create_clid_dir(cstate->session->se_client);
Mi Jinlongbcecf1c2011-04-27 09:14:30 +08001894out:
J. Bruce Fields4dc6ec02010-04-19 15:11:28 -04001895 nfs4_unlock_state();
Mi Jinlongbcecf1c2011-04-27 09:14:30 +08001896 return status;
J. Bruce Fields4dc6ec02010-04-19 15:11:28 -04001897}
1898
1899__be32
J.Bruce Fieldsb5914802006-12-13 00:35:38 -08001900nfsd4_setclientid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
1901 struct nfsd4_setclientid *setclid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001902{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001903 struct xdr_netobj clname = {
1904 .len = setclid->se_namelen,
1905 .data = setclid->se_name,
1906 };
1907 nfs4_verifier clverifier = setclid->se_verf;
1908 unsigned int strhashval;
NeilBrown28ce6052005-06-23 22:03:56 -07001909 struct nfs4_client *conf, *unconf, *new;
Al Virob37ad282006-10-19 23:28:59 -07001910 __be32 status;
NeilBrowna55370a2005-06-23 22:03:52 -07001911 char dname[HEXDIR_LEN];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001912
Linus Torvalds1da177e2005-04-16 15:20:36 -07001913 if (!check_name(clname))
Neil Brown73aea4e2005-09-13 01:25:39 -07001914 return nfserr_inval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001915
NeilBrowna55370a2005-06-23 22:03:52 -07001916 status = nfs4_make_rec_clidname(dname, &clname);
1917 if (status)
Neil Brown73aea4e2005-09-13 01:25:39 -07001918 return status;
NeilBrowna55370a2005-06-23 22:03:52 -07001919
Linus Torvalds1da177e2005-04-16 15:20:36 -07001920 /*
1921 * XXX The Duplicate Request Cache (DRC) has been checked (??)
1922 * We get here on a DRC miss.
1923 */
1924
NeilBrowna55370a2005-06-23 22:03:52 -07001925 strhashval = clientstr_hashval(dname);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001926
Linus Torvalds1da177e2005-04-16 15:20:36 -07001927 nfs4_lock_state();
J. Bruce Fieldse203d502010-11-24 17:30:54 -05001928 conf = find_confirmed_client_by_str(dname, strhashval);
NeilBrown28ce6052005-06-23 22:03:56 -07001929 if (conf) {
J. Bruce Fieldsa186e762007-11-20 16:11:27 -05001930 /* RFC 3530 14.2.33 CASE 0: */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001931 status = nfserr_clid_inuse;
J. Bruce Fieldse203d502010-11-24 17:30:54 -05001932 if (clp_used_exchangeid(conf))
1933 goto out;
J. Bruce Fields026722c2009-03-18 15:06:26 -04001934 if (!same_creds(&conf->cl_cred, &rqstp->rq_cred)) {
Jeff Layton363168b2009-08-14 12:57:56 -04001935 char addr_str[INET6_ADDRSTRLEN];
1936 rpc_ntop((struct sockaddr *) &conf->cl_addr, addr_str,
1937 sizeof(addr_str));
1938 dprintk("NFSD: setclientid: string in use by client "
1939 "at %s\n", addr_str);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001940 goto out;
1941 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001942 }
J. Bruce Fieldsa186e762007-11-20 16:11:27 -05001943 /*
1944 * section 14.2.33 of RFC 3530 (under the heading "IMPLEMENTATION")
1945 * has a description of SETCLIENTID request processing consisting
1946 * of 5 bullet points, labeled as CASE0 - CASE4 below.
1947 */
J. Bruce Fieldse203d502010-11-24 17:30:54 -05001948 unconf = find_unconfirmed_client_by_str(dname, strhashval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001949 status = nfserr_resource;
1950 if (!conf) {
J. Bruce Fieldsa186e762007-11-20 16:11:27 -05001951 /*
1952 * RFC 3530 14.2.33 CASE 4:
1953 * placed first, because it is the normal case
Linus Torvalds1da177e2005-04-16 15:20:36 -07001954 */
1955 if (unconf)
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);
J. Bruce Fields599e0a22007-07-26 17:04:54 -04001961 } else if (same_verf(&conf->cl_verifier, &clverifier)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001962 /*
J. Bruce Fieldsa186e762007-11-20 16:11:27 -05001963 * RFC 3530 14.2.33 CASE 1:
1964 * probable callback update
Linus Torvalds1da177e2005-04-16 15:20:36 -07001965 */
NeilBrown31f4a6c2005-06-23 22:04:06 -07001966 if (unconf) {
1967 /* Note this is removing unconfirmed {*x***},
1968 * which is stronger than RFC recommended {vxc**}.
1969 * This has the advantage that there is at most
1970 * one {*x***} in either list at any time.
1971 */
1972 expire_client(unconf);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001973 }
Ricardo Labiagab09333c2009-09-10 12:27:34 +03001974 new = create_client(clname, dname, rqstp, &clverifier);
NeilBrowna55370a2005-06-23 22:03:52 -07001975 if (new == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001976 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001977 copy_clid(new, conf);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001978 } else if (!unconf) {
1979 /*
J. Bruce Fieldsa186e762007-11-20 16:11:27 -05001980 * RFC 3530 14.2.33 CASE 2:
1981 * probable client reboot; state will be removed if
1982 * confirmed.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001983 */
Ricardo Labiagab09333c2009-09-10 12:27:34 +03001984 new = create_client(clname, dname, rqstp, &clverifier);
NeilBrowna55370a2005-06-23 22:03:52 -07001985 if (new == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001986 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001987 gen_clid(new);
J. Bruce Fields49ba8782007-11-19 19:09:50 -05001988 } else {
J. Bruce Fieldsa186e762007-11-20 16:11:27 -05001989 /*
1990 * RFC 3530 14.2.33 CASE 3:
1991 * probable client reboot; state will be removed if
1992 * confirmed.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001993 */
1994 expire_client(unconf);
Ricardo Labiagab09333c2009-09-10 12:27:34 +03001995 new = create_client(clname, dname, rqstp, &clverifier);
NeilBrowna55370a2005-06-23 22:03:52 -07001996 if (new == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001997 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001998 gen_clid(new);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001999 }
J. Bruce Fields8323c3b2010-10-19 19:36:51 -04002000 /*
2001 * XXX: we should probably set this at creation time, and check
2002 * for consistent minorversion use throughout:
2003 */
2004 new->cl_minorversion = 0;
Takuma Umeya6f3d7722010-12-15 14:09:01 +09002005 gen_callback(new, setclid, rqstp);
J. Bruce Fieldsc175b832007-08-09 18:34:32 -04002006 add_to_unconfirmed(new, strhashval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002007 setclid->se_clientid.cl_boot = new->cl_clientid.cl_boot;
2008 setclid->se_clientid.cl_id = new->cl_clientid.cl_id;
2009 memcpy(setclid->se_confirm.data, new->cl_confirm.data, sizeof(setclid->se_confirm.data));
2010 status = nfs_ok;
2011out:
2012 nfs4_unlock_state();
2013 return status;
2014}
2015
2016
2017/*
J. Bruce Fieldsa186e762007-11-20 16:11:27 -05002018 * Section 14.2.34 of RFC 3530 (under the heading "IMPLEMENTATION") has
2019 * a description of SETCLIENTID_CONFIRM request processing consisting of 4
2020 * bullets, labeled as CASE1 - CASE4 below.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002021 */
Al Virob37ad282006-10-19 23:28:59 -07002022__be32
J.Bruce Fieldsb5914802006-12-13 00:35:38 -08002023nfsd4_setclientid_confirm(struct svc_rqst *rqstp,
2024 struct nfsd4_compound_state *cstate,
2025 struct nfsd4_setclientid_confirm *setclientid_confirm)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002026{
Jeff Layton363168b2009-08-14 12:57:56 -04002027 struct sockaddr *sa = svc_addr(rqstp);
NeilBrown21ab45a2005-06-23 22:04:14 -07002028 struct nfs4_client *conf, *unconf;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002029 nfs4_verifier confirm = setclientid_confirm->sc_confirm;
2030 clientid_t * clid = &setclientid_confirm->sc_clientid;
Al Virob37ad282006-10-19 23:28:59 -07002031 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002032
2033 if (STALE_CLIENTID(clid))
2034 return nfserr_stale_clientid;
2035 /*
2036 * XXX The Duplicate Request Cache (DRC) has been checked (??)
2037 * We get here on a DRC miss.
2038 */
2039
2040 nfs4_lock_state();
NeilBrown21ab45a2005-06-23 22:04:14 -07002041
2042 conf = find_confirmed_client(clid);
2043 unconf = find_unconfirmed_client(clid);
2044
2045 status = nfserr_clid_inuse;
Jeff Layton363168b2009-08-14 12:57:56 -04002046 if (conf && !rpc_cmp_addr((struct sockaddr *) &conf->cl_addr, sa))
NeilBrown21ab45a2005-06-23 22:04:14 -07002047 goto out;
Jeff Layton363168b2009-08-14 12:57:56 -04002048 if (unconf && !rpc_cmp_addr((struct sockaddr *) &unconf->cl_addr, sa))
NeilBrown21ab45a2005-06-23 22:04:14 -07002049 goto out;
2050
J. Bruce Fieldsa186e762007-11-20 16:11:27 -05002051 /*
2052 * section 14.2.34 of RFC 3530 has a description of
2053 * SETCLIENTID_CONFIRM request processing consisting
2054 * of 4 bullet points, labeled as CASE1 - CASE4 below.
2055 */
J. Bruce Fields366e0c12007-11-20 15:54:10 -05002056 if (conf && unconf && same_verf(&confirm, &unconf->cl_confirm)) {
J. Bruce Fieldsa186e762007-11-20 16:11:27 -05002057 /*
2058 * RFC 3530 14.2.34 CASE 1:
2059 * callback update
2060 */
J. Bruce Fields599e0a22007-07-26 17:04:54 -04002061 if (!same_creds(&conf->cl_cred, &unconf->cl_cred))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002062 status = nfserr_clid_inuse;
2063 else {
J. Bruce Fields5a3c9d72010-10-19 17:56:52 -04002064 nfsd4_change_callback(conf, &unconf->cl_cb_conn);
2065 nfsd4_probe_callback(conf);
NeilBrown1a69c172005-06-23 22:04:08 -07002066 expire_client(unconf);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002067 status = nfs_ok;
NeilBrown1a69c172005-06-23 22:04:08 -07002068
Linus Torvalds1da177e2005-04-16 15:20:36 -07002069 }
J. Bruce Fieldsf3aba4e2007-11-20 16:52:07 -05002070 } else if (conf && !unconf) {
J. Bruce Fieldsa186e762007-11-20 16:11:27 -05002071 /*
2072 * RFC 3530 14.2.34 CASE 2:
2073 * probable retransmitted request; play it safe and
2074 * do nothing.
NeilBrown7c79f732005-06-23 22:04:13 -07002075 */
J. Bruce Fields599e0a22007-07-26 17:04:54 -04002076 if (!same_creds(&conf->cl_cred, &rqstp->rq_cred))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002077 status = nfserr_clid_inuse;
NeilBrown21ab45a2005-06-23 22:04:14 -07002078 else
Linus Torvalds1da177e2005-04-16 15:20:36 -07002079 status = nfs_ok;
NeilBrown7c79f732005-06-23 22:04:13 -07002080 } else if (!conf && unconf
J. Bruce Fields599e0a22007-07-26 17:04:54 -04002081 && same_verf(&unconf->cl_confirm, &confirm)) {
J. Bruce Fieldsa186e762007-11-20 16:11:27 -05002082 /*
2083 * RFC 3530 14.2.34 CASE 3:
2084 * Normal case; new or rebooted client:
NeilBrown7c79f732005-06-23 22:04:13 -07002085 */
J. Bruce Fields599e0a22007-07-26 17:04:54 -04002086 if (!same_creds(&unconf->cl_cred, &rqstp->rq_cred)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002087 status = nfserr_clid_inuse;
2088 } else {
NeilBrown1a69c172005-06-23 22:04:08 -07002089 unsigned int hash =
2090 clientstr_hashval(unconf->cl_recdir);
2091 conf = find_confirmed_client_by_str(unconf->cl_recdir,
J. Bruce Fieldse203d502010-11-24 17:30:54 -05002092 hash);
NeilBrown1a69c172005-06-23 22:04:08 -07002093 if (conf) {
NeilBrownc7b9a452005-06-23 22:04:30 -07002094 nfsd4_remove_clid_dir(conf);
NeilBrown1a69c172005-06-23 22:04:08 -07002095 expire_client(conf);
2096 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002097 move_to_confirmed(unconf);
NeilBrown21ab45a2005-06-23 22:04:14 -07002098 conf = unconf;
J. Bruce Fields5a3c9d72010-10-19 17:56:52 -04002099 nfsd4_probe_callback(conf);
NeilBrown1a69c172005-06-23 22:04:08 -07002100 status = nfs_ok;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002101 }
J. Bruce Fields599e0a22007-07-26 17:04:54 -04002102 } else if ((!conf || (conf && !same_verf(&conf->cl_confirm, &confirm)))
2103 && (!unconf || (unconf && !same_verf(&unconf->cl_confirm,
NeilBrown7c79f732005-06-23 22:04:13 -07002104 &confirm)))) {
J. Bruce Fieldsa186e762007-11-20 16:11:27 -05002105 /*
2106 * RFC 3530 14.2.34 CASE 4:
2107 * Client probably hasn't noticed that we rebooted yet.
NeilBrown7c79f732005-06-23 22:04:13 -07002108 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002109 status = nfserr_stale_clientid;
NeilBrown7c79f732005-06-23 22:04:13 -07002110 } else {
NeilBrown08e89872005-06-23 22:04:11 -07002111 /* check that we have hit one of the cases...*/
2112 status = nfserr_clid_inuse;
2113 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002114out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002115 nfs4_unlock_state();
2116 return status;
2117}
2118
Linus Torvalds1da177e2005-04-16 15:20:36 -07002119/* OPEN Share state helper functions */
2120static inline struct nfs4_file *
2121alloc_init_file(struct inode *ino)
2122{
2123 struct nfs4_file *fp;
2124 unsigned int hashval = file_hashval(ino);
2125
NeilBrowne60d4392005-06-23 22:03:01 -07002126 fp = kmem_cache_alloc(file_slab, GFP_KERNEL);
2127 if (fp) {
J. Bruce Fields8b671b82009-02-22 14:51:34 -08002128 atomic_set(&fp->fi_ref, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002129 INIT_LIST_HEAD(&fp->fi_hash);
NeilBrown8beefa22005-06-23 22:03:08 -07002130 INIT_LIST_HEAD(&fp->fi_stateids);
2131 INIT_LIST_HEAD(&fp->fi_delegations);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002132 fp->fi_inode = igrab(ino);
2133 fp->fi_id = current_fileid++;
Meelap Shah47f99402007-07-17 04:04:40 -07002134 fp->fi_had_conflict = false;
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05002135 fp->fi_lease = NULL;
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04002136 memset(fp->fi_fds, 0, sizeof(fp->fi_fds));
2137 memset(fp->fi_access, 0, sizeof(fp->fi_access));
Pavel Emelyanov47cee542010-05-17 20:00:37 +04002138 spin_lock(&recall_lock);
2139 list_add(&fp->fi_hash, &file_hashtbl[hashval]);
2140 spin_unlock(&recall_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002141 return fp;
2142 }
2143 return NULL;
2144}
2145
2146static void
Christoph Lametere18b8902006-12-06 20:33:20 -08002147nfsd4_free_slab(struct kmem_cache **slab)
NeilBrowne60d4392005-06-23 22:03:01 -07002148{
NeilBrowne60d4392005-06-23 22:03:01 -07002149 if (*slab == NULL)
2150 return;
Alexey Dobriyan1a1d92c2006-09-27 01:49:40 -07002151 kmem_cache_destroy(*slab);
NeilBrowne60d4392005-06-23 22:03:01 -07002152 *slab = NULL;
NeilBrowne60d4392005-06-23 22:03:01 -07002153}
2154
J. Bruce Fieldse8ff2a82007-08-01 15:30:59 -04002155void
NeilBrowne60d4392005-06-23 22:03:01 -07002156nfsd4_free_slabs(void)
2157{
2158 nfsd4_free_slab(&stateowner_slab);
2159 nfsd4_free_slab(&file_slab);
NeilBrown5ac049a2005-06-23 22:03:03 -07002160 nfsd4_free_slab(&stateid_slab);
NeilBrown5b2d21c2005-06-23 22:03:04 -07002161 nfsd4_free_slab(&deleg_slab);
NeilBrowne60d4392005-06-23 22:03:01 -07002162}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002163
2164static int
2165nfsd4_init_slabs(void)
2166{
2167 stateowner_slab = kmem_cache_create("nfsd4_stateowners",
Paul Mundt20c2df82007-07-20 10:11:58 +09002168 sizeof(struct nfs4_stateowner), 0, 0, NULL);
NeilBrowne60d4392005-06-23 22:03:01 -07002169 if (stateowner_slab == NULL)
2170 goto out_nomem;
2171 file_slab = kmem_cache_create("nfsd4_files",
Paul Mundt20c2df82007-07-20 10:11:58 +09002172 sizeof(struct nfs4_file), 0, 0, NULL);
NeilBrowne60d4392005-06-23 22:03:01 -07002173 if (file_slab == NULL)
2174 goto out_nomem;
NeilBrown5ac049a2005-06-23 22:03:03 -07002175 stateid_slab = kmem_cache_create("nfsd4_stateids",
Paul Mundt20c2df82007-07-20 10:11:58 +09002176 sizeof(struct nfs4_stateid), 0, 0, NULL);
NeilBrown5ac049a2005-06-23 22:03:03 -07002177 if (stateid_slab == NULL)
2178 goto out_nomem;
NeilBrown5b2d21c2005-06-23 22:03:04 -07002179 deleg_slab = kmem_cache_create("nfsd4_delegations",
Paul Mundt20c2df82007-07-20 10:11:58 +09002180 sizeof(struct nfs4_delegation), 0, 0, NULL);
NeilBrown5b2d21c2005-06-23 22:03:04 -07002181 if (deleg_slab == NULL)
2182 goto out_nomem;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002183 return 0;
NeilBrowne60d4392005-06-23 22:03:01 -07002184out_nomem:
2185 nfsd4_free_slabs();
2186 dprintk("nfsd4: out of memory while initializing nfsv4\n");
2187 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002188}
2189
2190void
2191nfs4_free_stateowner(struct kref *kref)
2192{
2193 struct nfs4_stateowner *sop =
2194 container_of(kref, struct nfs4_stateowner, so_ref);
2195 kfree(sop->so_owner.data);
2196 kmem_cache_free(stateowner_slab, sop);
2197}
2198
2199static inline struct nfs4_stateowner *
2200alloc_stateowner(struct xdr_netobj *owner)
2201{
2202 struct nfs4_stateowner *sop;
2203
2204 if ((sop = kmem_cache_alloc(stateowner_slab, GFP_KERNEL))) {
2205 if ((sop->so_owner.data = kmalloc(owner->len, GFP_KERNEL))) {
2206 memcpy(sop->so_owner.data, owner->data, owner->len);
2207 sop->so_owner.len = owner->len;
2208 kref_init(&sop->so_ref);
2209 return sop;
2210 }
2211 kmem_cache_free(stateowner_slab, sop);
2212 }
2213 return NULL;
2214}
2215
2216static struct nfs4_stateowner *
2217alloc_init_open_stateowner(unsigned int strhashval, struct nfs4_client *clp, struct nfsd4_open *open) {
2218 struct nfs4_stateowner *sop;
2219 struct nfs4_replay *rp;
2220 unsigned int idhashval;
2221
2222 if (!(sop = alloc_stateowner(&open->op_owner)))
2223 return NULL;
2224 idhashval = ownerid_hashval(current_ownerid);
2225 INIT_LIST_HEAD(&sop->so_idhash);
2226 INIT_LIST_HEAD(&sop->so_strhash);
2227 INIT_LIST_HEAD(&sop->so_perclient);
NeilBrownea1da632005-06-23 22:04:17 -07002228 INIT_LIST_HEAD(&sop->so_stateids);
2229 INIT_LIST_HEAD(&sop->so_perstateid); /* not used */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002230 INIT_LIST_HEAD(&sop->so_close_lru);
2231 sop->so_time = 0;
2232 list_add(&sop->so_idhash, &ownerid_hashtbl[idhashval]);
2233 list_add(&sop->so_strhash, &ownerstr_hashtbl[strhashval]);
NeilBrownea1da632005-06-23 22:04:17 -07002234 list_add(&sop->so_perclient, &clp->cl_openowners);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002235 sop->so_is_open_owner = 1;
2236 sop->so_id = current_ownerid++;
2237 sop->so_client = clp;
2238 sop->so_seqid = open->op_seqid;
2239 sop->so_confirmed = 0;
2240 rp = &sop->so_replay;
Al Virode1ae282006-01-18 17:43:47 -08002241 rp->rp_status = nfserr_serverfault;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002242 rp->rp_buflen = 0;
2243 rp->rp_buf = rp->rp_ibuf;
2244 return sop;
2245}
2246
Linus Torvalds1da177e2005-04-16 15:20:36 -07002247static inline void
2248init_stateid(struct nfs4_stateid *stp, struct nfs4_file *fp, struct nfsd4_open *open) {
2249 struct nfs4_stateowner *sop = open->op_stateowner;
2250 unsigned int hashval = stateid_hashval(sop->so_id, fp->fi_id);
2251
2252 INIT_LIST_HEAD(&stp->st_hash);
NeilBrownea1da632005-06-23 22:04:17 -07002253 INIT_LIST_HEAD(&stp->st_perstateowner);
2254 INIT_LIST_HEAD(&stp->st_lockowners);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002255 INIT_LIST_HEAD(&stp->st_perfile);
2256 list_add(&stp->st_hash, &stateid_hashtbl[hashval]);
NeilBrownea1da632005-06-23 22:04:17 -07002257 list_add(&stp->st_perstateowner, &sop->so_stateids);
NeilBrown8beefa22005-06-23 22:03:08 -07002258 list_add(&stp->st_perfile, &fp->fi_stateids);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002259 stp->st_stateowner = sop;
NeilBrown13cd2182005-06-23 22:03:10 -07002260 get_nfs4_file(fp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002261 stp->st_file = fp;
J. Bruce Fieldse4e83ea2010-04-22 16:21:39 -04002262 stp->st_stateid.si_boot = boot_time;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002263 stp->st_stateid.si_stateownerid = sop->so_id;
2264 stp->st_stateid.si_fileid = fp->fi_id;
2265 stp->st_stateid.si_generation = 0;
2266 stp->st_access_bmap = 0;
2267 stp->st_deny_bmap = 0;
Andy Adamson84459a12009-04-03 08:28:56 +03002268 __set_bit(open->op_share_access & ~NFS4_SHARE_WANT_MASK,
2269 &stp->st_access_bmap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002270 __set_bit(open->op_share_deny, &stp->st_deny_bmap);
NeilBrown4c4cd222005-07-07 17:59:27 -07002271 stp->st_openstp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002272}
2273
2274static void
Linus Torvalds1da177e2005-04-16 15:20:36 -07002275move_to_close_lru(struct nfs4_stateowner *sop)
2276{
2277 dprintk("NFSD: move_to_close_lru nfs4_stateowner %p\n", sop);
2278
NeilBrown358dd552006-04-10 22:55:42 -07002279 list_move_tail(&sop->so_close_lru, &close_lru);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002280 sop->so_time = get_seconds();
2281}
2282
Linus Torvalds1da177e2005-04-16 15:20:36 -07002283static int
J. Bruce Fields599e0a22007-07-26 17:04:54 -04002284same_owner_str(struct nfs4_stateowner *sop, struct xdr_netobj *owner,
2285 clientid_t *clid)
2286{
2287 return (sop->so_owner.len == owner->len) &&
2288 0 == memcmp(sop->so_owner.data, owner->data, owner->len) &&
2289 (sop->so_client->cl_clientid.cl_id == clid->cl_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002290}
2291
2292static struct nfs4_stateowner *
2293find_openstateowner_str(unsigned int hashval, struct nfsd4_open *open)
2294{
2295 struct nfs4_stateowner *so = NULL;
2296
2297 list_for_each_entry(so, &ownerstr_hashtbl[hashval], so_strhash) {
J. Bruce Fields599e0a22007-07-26 17:04:54 -04002298 if (same_owner_str(so, &open->op_owner, &open->op_clientid))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002299 return so;
2300 }
2301 return NULL;
2302}
2303
2304/* search file_hashtbl[] for file */
2305static struct nfs4_file *
2306find_file(struct inode *ino)
2307{
2308 unsigned int hashval = file_hashval(ino);
2309 struct nfs4_file *fp;
2310
J. Bruce Fields8b671b82009-02-22 14:51:34 -08002311 spin_lock(&recall_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002312 list_for_each_entry(fp, &file_hashtbl[hashval], fi_hash) {
NeilBrown13cd2182005-06-23 22:03:10 -07002313 if (fp->fi_inode == ino) {
2314 get_nfs4_file(fp);
J. Bruce Fields8b671b82009-02-22 14:51:34 -08002315 spin_unlock(&recall_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002316 return fp;
NeilBrown13cd2182005-06-23 22:03:10 -07002317 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002318 }
J. Bruce Fields8b671b82009-02-22 14:51:34 -08002319 spin_unlock(&recall_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002320 return NULL;
2321}
2322
Andy Adamsond87a8ad2009-04-03 08:28:53 +03002323static inline int access_valid(u32 x, u32 minorversion)
J. Bruce Fieldsba5a6a12006-06-30 01:56:16 -07002324{
Andy Adamsond87a8ad2009-04-03 08:28:53 +03002325 if ((x & NFS4_SHARE_ACCESS_MASK) < NFS4_SHARE_ACCESS_READ)
J. Bruce Fields8838dc42008-01-14 13:12:19 -05002326 return 0;
Andy Adamsond87a8ad2009-04-03 08:28:53 +03002327 if ((x & NFS4_SHARE_ACCESS_MASK) > NFS4_SHARE_ACCESS_BOTH)
2328 return 0;
2329 x &= ~NFS4_SHARE_ACCESS_MASK;
2330 if (minorversion && x) {
2331 if ((x & NFS4_SHARE_WANT_MASK) > NFS4_SHARE_WANT_CANCEL)
2332 return 0;
2333 if ((x & NFS4_SHARE_WHEN_MASK) > NFS4_SHARE_PUSH_DELEG_WHEN_UNCONTENDED)
2334 return 0;
2335 x &= ~(NFS4_SHARE_WANT_MASK | NFS4_SHARE_WHEN_MASK);
2336 }
2337 if (x)
J. Bruce Fields8838dc42008-01-14 13:12:19 -05002338 return 0;
2339 return 1;
J. Bruce Fieldsba5a6a12006-06-30 01:56:16 -07002340}
2341
J. Bruce Fields8838dc42008-01-14 13:12:19 -05002342static inline int deny_valid(u32 x)
J. Bruce Fieldsba5a6a12006-06-30 01:56:16 -07002343{
J. Bruce Fields8838dc42008-01-14 13:12:19 -05002344 /* Note: unlike access bits, deny bits may be zero. */
2345 return x <= NFS4_SHARE_DENY_BOTH;
J. Bruce Fieldsba5a6a12006-06-30 01:56:16 -07002346}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002347
J. Bruce Fields4f83aa32008-07-07 15:02:02 -04002348/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002349 * Called to check deny when READ with all zero stateid or
2350 * WRITE with all zero or all one stateid
2351 */
Al Virob37ad282006-10-19 23:28:59 -07002352static __be32
Linus Torvalds1da177e2005-04-16 15:20:36 -07002353nfs4_share_conflict(struct svc_fh *current_fh, unsigned int deny_type)
2354{
2355 struct inode *ino = current_fh->fh_dentry->d_inode;
2356 struct nfs4_file *fp;
2357 struct nfs4_stateid *stp;
Al Virob37ad282006-10-19 23:28:59 -07002358 __be32 ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002359
2360 dprintk("NFSD: nfs4_share_conflict\n");
2361
2362 fp = find_file(ino);
NeilBrown13cd2182005-06-23 22:03:10 -07002363 if (!fp)
2364 return nfs_ok;
NeilBrownb7009492005-07-07 17:59:23 -07002365 ret = nfserr_locked;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002366 /* Search for conflicting share reservations */
NeilBrown13cd2182005-06-23 22:03:10 -07002367 list_for_each_entry(stp, &fp->fi_stateids, st_perfile) {
2368 if (test_bit(deny_type, &stp->st_deny_bmap) ||
2369 test_bit(NFS4_SHARE_DENY_BOTH, &stp->st_deny_bmap))
2370 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002371 }
NeilBrown13cd2182005-06-23 22:03:10 -07002372 ret = nfs_ok;
2373out:
2374 put_nfs4_file(fp);
2375 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002376}
2377
J. Bruce Fields6b57d9c2011-01-31 11:54:04 -05002378static void nfsd_break_one_deleg(struct nfs4_delegation *dp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002379{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002380 /* We're assuming the state code never drops its reference
2381 * without first removing the lease. Since we're in this lease
2382 * callback (and since the lease code is serialized by the kernel
2383 * lock) we know the server hasn't removed the lease yet, we know
2384 * it's safe to take a reference: */
2385 atomic_inc(&dp->dl_count);
2386
Linus Torvalds1da177e2005-04-16 15:20:36 -07002387 list_add_tail(&dp->dl_recall_lru, &del_recall_lru);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002388
Arnd Bergmann460781b2010-11-17 16:26:56 +01002389 /* only place dl_time is set. protected by lock_flocks*/
Linus Torvalds1da177e2005-04-16 15:20:36 -07002390 dp->dl_time = get_seconds();
2391
J. Bruce Fields6b57d9c2011-01-31 11:54:04 -05002392 nfsd4_cb_recall(dp);
2393}
2394
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05002395/* Called from break_lease() with lock_flocks() held. */
J. Bruce Fields6b57d9c2011-01-31 11:54:04 -05002396static void nfsd_break_deleg_cb(struct file_lock *fl)
2397{
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05002398 struct nfs4_file *fp = (struct nfs4_file *)fl->fl_owner;
2399 struct nfs4_delegation *dp;
J. Bruce Fields6b57d9c2011-01-31 11:54:04 -05002400
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05002401 BUG_ON(!fp);
2402 /* We assume break_lease is only called once per lease: */
2403 BUG_ON(fp->fi_had_conflict);
J. Bruce Fields0272e1f2007-09-12 18:56:12 -04002404 /*
2405 * We don't want the locks code to timeout the lease for us;
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05002406 * we'll remove it ourself if a delegation isn't returned
J. Bruce Fields6b57d9c2011-01-31 11:54:04 -05002407 * in time:
J. Bruce Fields0272e1f2007-09-12 18:56:12 -04002408 */
2409 fl->fl_break_time = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002410
J. Bruce Fields5d926e82011-02-07 16:53:46 -05002411 spin_lock(&recall_lock);
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05002412 fp->fi_had_conflict = true;
2413 list_for_each_entry(dp, &fp->fi_delegations, dl_perfile)
2414 nfsd_break_one_deleg(dp);
J. Bruce Fields5d926e82011-02-07 16:53:46 -05002415 spin_unlock(&recall_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002416}
2417
Linus Torvalds1da177e2005-04-16 15:20:36 -07002418static
2419int nfsd_change_deleg_cb(struct file_lock **onlist, int arg)
2420{
2421 if (arg & F_UNLCK)
2422 return lease_modify(onlist, arg);
2423 else
2424 return -EAGAIN;
2425}
2426
Alexey Dobriyan7b021962009-09-21 17:01:12 -07002427static const struct lock_manager_operations nfsd_lease_mng_ops = {
J. Bruce Fields8fb47a42011-07-20 20:21:59 -04002428 .lm_break = nfsd_break_deleg_cb,
2429 .lm_change = nfsd_change_deleg_cb,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002430};
2431
2432
Al Virob37ad282006-10-19 23:28:59 -07002433__be32
Andy Adamson66689582009-04-03 08:28:45 +03002434nfsd4_process_open1(struct nfsd4_compound_state *cstate,
2435 struct nfsd4_open *open)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002436{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002437 clientid_t *clientid = &open->op_clientid;
2438 struct nfs4_client *clp = NULL;
2439 unsigned int strhashval;
2440 struct nfs4_stateowner *sop = NULL;
2441
Linus Torvalds1da177e2005-04-16 15:20:36 -07002442 if (!check_name(open->op_owner))
J. Bruce Fields0f442aa2006-01-18 17:43:34 -08002443 return nfserr_inval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002444
2445 if (STALE_CLIENTID(&open->op_clientid))
2446 return nfserr_stale_clientid;
2447
2448 strhashval = ownerstr_hashval(clientid->cl_id, open->op_owner);
2449 sop = find_openstateowner_str(strhashval, open);
J. Bruce Fields0f442aa2006-01-18 17:43:34 -08002450 open->op_stateowner = sop;
2451 if (!sop) {
2452 /* Make sure the client's lease hasn't expired. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002453 clp = find_confirmed_client(clientid);
2454 if (clp == NULL)
J. Bruce Fields0f442aa2006-01-18 17:43:34 -08002455 return nfserr_expired;
2456 goto renew;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002457 }
Andy Adamson66689582009-04-03 08:28:45 +03002458 /* When sessions are used, skip open sequenceid processing */
2459 if (nfsd4_has_session(cstate))
2460 goto renew;
J. Bruce Fields0f442aa2006-01-18 17:43:34 -08002461 if (!sop->so_confirmed) {
2462 /* Replace unconfirmed owners without checking for replay. */
2463 clp = sop->so_client;
J. Bruce Fieldsf044ff82009-01-11 15:24:04 -05002464 release_openowner(sop);
J. Bruce Fields0f442aa2006-01-18 17:43:34 -08002465 open->op_stateowner = NULL;
2466 goto renew;
2467 }
2468 if (open->op_seqid == sop->so_seqid - 1) {
2469 if (sop->so_replay.rp_buflen)
Al Viroa90b0612006-10-19 23:29:03 -07002470 return nfserr_replay_me;
J. Bruce Fields0f442aa2006-01-18 17:43:34 -08002471 /* The original OPEN failed so spectacularly
2472 * that we don't even have replay data saved!
2473 * Therefore, we have no choice but to continue
2474 * processing this OPEN; presumably, we'll
2475 * fail again for the same reason.
2476 */
2477 dprintk("nfsd4_process_open1: replay with no replay cache\n");
2478 goto renew;
2479 }
2480 if (open->op_seqid != sop->so_seqid)
2481 return nfserr_bad_seqid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002482renew:
J. Bruce Fields0f442aa2006-01-18 17:43:34 -08002483 if (open->op_stateowner == NULL) {
2484 sop = alloc_init_open_stateowner(strhashval, clp, open);
2485 if (sop == NULL)
2486 return nfserr_resource;
2487 open->op_stateowner = sop;
2488 }
2489 list_del_init(&sop->so_close_lru);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002490 renew_client(sop->so_client);
J. Bruce Fields0f442aa2006-01-18 17:43:34 -08002491 return nfs_ok;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002492}
2493
Al Virob37ad282006-10-19 23:28:59 -07002494static inline __be32
NeilBrown4a6e43e2005-06-23 22:02:50 -07002495nfs4_check_delegmode(struct nfs4_delegation *dp, int flags)
2496{
2497 if ((flags & WR_STATE) && (dp->dl_type == NFS4_OPEN_DELEGATE_READ))
2498 return nfserr_openmode;
2499 else
2500 return nfs_ok;
2501}
2502
NeilBrown52f4fb42005-06-23 22:02:49 -07002503static struct nfs4_delegation *
2504find_delegation_file(struct nfs4_file *fp, stateid_t *stid)
2505{
J. Bruce Fields32b007b2011-03-06 19:11:03 -05002506 struct nfs4_delegation *dp;
NeilBrown52f4fb42005-06-23 22:02:49 -07002507
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05002508 spin_lock(&recall_lock);
J. Bruce Fields32b007b2011-03-06 19:11:03 -05002509 list_for_each_entry(dp, &fp->fi_delegations, dl_perfile)
2510 if (dp->dl_stateid.si_stateownerid == stid->si_stateownerid) {
2511 spin_unlock(&recall_lock);
2512 return dp;
2513 }
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05002514 spin_unlock(&recall_lock);
J. Bruce Fields32b007b2011-03-06 19:11:03 -05002515 return NULL;
NeilBrown52f4fb42005-06-23 22:02:49 -07002516}
2517
Daniel Mackc47d8322011-05-16 16:38:14 +02002518static int share_access_to_flags(u32 share_access)
J. Bruce Fields24a01112010-05-18 20:01:35 -04002519{
2520 share_access &= ~NFS4_SHARE_WANT_MASK;
2521
2522 return share_access == NFS4_SHARE_ACCESS_READ ? RD_STATE : WR_STATE;
2523}
2524
Al Virob37ad282006-10-19 23:28:59 -07002525static __be32
NeilBrown567d9822005-06-23 22:02:53 -07002526nfs4_check_deleg(struct nfs4_file *fp, struct nfsd4_open *open,
2527 struct nfs4_delegation **dp)
2528{
2529 int flags;
Al Virob37ad282006-10-19 23:28:59 -07002530 __be32 status = nfserr_bad_stateid;
NeilBrown567d9822005-06-23 22:02:53 -07002531
2532 *dp = find_delegation_file(fp, &open->op_delegate_stateid);
2533 if (*dp == NULL)
NeilBrownc44c5ee2005-06-23 22:02:54 -07002534 goto out;
J. Bruce Fields24a01112010-05-18 20:01:35 -04002535 flags = share_access_to_flags(open->op_share_access);
NeilBrown567d9822005-06-23 22:02:53 -07002536 status = nfs4_check_delegmode(*dp, flags);
2537 if (status)
2538 *dp = NULL;
NeilBrownc44c5ee2005-06-23 22:02:54 -07002539out:
2540 if (open->op_claim_type != NFS4_OPEN_CLAIM_DELEGATE_CUR)
2541 return nfs_ok;
2542 if (status)
2543 return status;
2544 open->op_stateowner->so_confirmed = 1;
2545 return nfs_ok;
NeilBrown567d9822005-06-23 22:02:53 -07002546}
2547
Al Virob37ad282006-10-19 23:28:59 -07002548static __be32
Linus Torvalds1da177e2005-04-16 15:20:36 -07002549nfs4_check_open(struct nfs4_file *fp, struct nfsd4_open *open, struct nfs4_stateid **stpp)
2550{
2551 struct nfs4_stateid *local;
Al Virob37ad282006-10-19 23:28:59 -07002552 __be32 status = nfserr_share_denied;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002553 struct nfs4_stateowner *sop = open->op_stateowner;
2554
NeilBrown8beefa22005-06-23 22:03:08 -07002555 list_for_each_entry(local, &fp->fi_stateids, st_perfile) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002556 /* ignore lock owners */
2557 if (local->st_stateowner->so_is_open_owner == 0)
2558 continue;
2559 /* remember if we have seen this open owner */
2560 if (local->st_stateowner == sop)
2561 *stpp = local;
2562 /* check for conflicting share reservations */
2563 if (!test_share(local, open))
2564 goto out;
2565 }
2566 status = 0;
2567out:
2568 return status;
2569}
2570
NeilBrown5ac049a2005-06-23 22:03:03 -07002571static inline struct nfs4_stateid *
2572nfs4_alloc_stateid(void)
2573{
2574 return kmem_cache_alloc(stateid_slab, GFP_KERNEL);
2575}
2576
J. Bruce Fields21fb4012010-07-28 12:21:23 -04002577static inline int nfs4_access_to_access(u32 nfs4_access)
2578{
2579 int flags = 0;
2580
2581 if (nfs4_access & NFS4_SHARE_ACCESS_READ)
2582 flags |= NFSD_MAY_READ;
2583 if (nfs4_access & NFS4_SHARE_ACCESS_WRITE)
2584 flags |= NFSD_MAY_WRITE;
2585 return flags;
2586}
2587
Casey Bodley0c12eaf2011-07-23 14:58:10 -04002588static __be32 nfs4_get_vfs_file(struct svc_rqst *rqstp, struct nfs4_file *fp,
2589 struct svc_fh *cur_fh, struct nfsd4_open *open)
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04002590{
2591 __be32 status;
Casey Bodley0c12eaf2011-07-23 14:58:10 -04002592 int oflag = nfs4_access_to_omode(open->op_share_access);
2593 int access = nfs4_access_to_access(open->op_share_access);
2594
2595 /* CLAIM_DELEGATE_CUR is used in response to a broken lease;
2596 * allowing it to break the lease and return EAGAIN leaves the
2597 * client unable to make progress in returning the delegation */
2598 if (open->op_claim_type == NFS4_OPEN_CLAIM_DELEGATE_CUR)
2599 access |= NFSD_MAY_NOT_BREAK_LEASE;
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04002600
2601 if (!fp->fi_fds[oflag]) {
2602 status = nfsd_open(rqstp, cur_fh, S_IFREG, access,
2603 &fp->fi_fds[oflag]);
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04002604 if (status)
2605 return status;
2606 }
2607 nfs4_file_get_access(fp, oflag);
2608
2609 return nfs_ok;
2610}
2611
Al Virob37ad282006-10-19 23:28:59 -07002612static __be32
Linus Torvalds1da177e2005-04-16 15:20:36 -07002613nfs4_new_open(struct svc_rqst *rqstp, struct nfs4_stateid **stpp,
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04002614 struct nfs4_file *fp, struct svc_fh *cur_fh,
2615 struct nfsd4_open *open)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002616{
2617 struct nfs4_stateid *stp;
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04002618 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002619
NeilBrown5ac049a2005-06-23 22:03:03 -07002620 stp = nfs4_alloc_stateid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002621 if (stp == NULL)
2622 return nfserr_resource;
2623
Casey Bodley0c12eaf2011-07-23 14:58:10 -04002624 status = nfs4_get_vfs_file(rqstp, fp, cur_fh, open);
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04002625 if (status) {
2626 kmem_cache_free(stateid_slab, stp);
2627 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002628 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002629 *stpp = stp;
2630 return 0;
2631}
2632
Al Virob37ad282006-10-19 23:28:59 -07002633static inline __be32
Linus Torvalds1da177e2005-04-16 15:20:36 -07002634nfsd4_truncate(struct svc_rqst *rqstp, struct svc_fh *fh,
2635 struct nfsd4_open *open)
2636{
2637 struct iattr iattr = {
2638 .ia_valid = ATTR_SIZE,
2639 .ia_size = 0,
2640 };
2641 if (!open->op_truncate)
2642 return 0;
2643 if (!(open->op_share_access & NFS4_SHARE_ACCESS_WRITE))
Al Viro92465852006-01-18 17:43:46 -08002644 return nfserr_inval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002645 return nfsd_setattr(rqstp, fh, &iattr, 0, (time_t)0);
2646}
2647
Al Virob37ad282006-10-19 23:28:59 -07002648static __be32
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04002649nfs4_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 -07002650{
J. Bruce Fields7d947842010-08-20 18:09:31 -04002651 u32 op_share_access = open->op_share_access & ~NFS4_SHARE_WANT_MASK;
2652 bool new_access;
Al Virob37ad282006-10-19 23:28:59 -07002653 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002654
J. Bruce Fields7d947842010-08-20 18:09:31 -04002655 new_access = !test_bit(op_share_access, &stp->st_access_bmap);
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04002656 if (new_access) {
Casey Bodley0c12eaf2011-07-23 14:58:10 -04002657 status = nfs4_get_vfs_file(rqstp, fp, cur_fh, open);
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04002658 if (status)
2659 return status;
J. Bruce Fields6c26d082006-01-18 17:43:38 -08002660 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002661 status = nfsd4_truncate(rqstp, cur_fh, open);
2662 if (status) {
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04002663 if (new_access) {
J. Bruce Fieldsf197c272011-06-29 08:23:50 -04002664 int oflag = nfs4_access_to_omode(op_share_access);
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04002665 nfs4_file_put_access(fp, oflag);
2666 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002667 return status;
2668 }
2669 /* remember the open */
J. Bruce Fields24a01112010-05-18 20:01:35 -04002670 __set_bit(op_share_access, &stp->st_access_bmap);
J. Bruce Fieldsb55e0ba2008-04-28 18:22:50 -04002671 __set_bit(open->op_share_deny, &stp->st_deny_bmap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002672
2673 return nfs_ok;
2674}
2675
2676
Linus Torvalds1da177e2005-04-16 15:20:36 -07002677static void
NeilBrown37515172005-07-07 17:59:16 -07002678nfs4_set_claim_prev(struct nfsd4_open *open)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002679{
NeilBrown37515172005-07-07 17:59:16 -07002680 open->op_stateowner->so_confirmed = 1;
2681 open->op_stateowner->so_client->cl_firststate = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002682}
2683
J. Bruce Fields14a24e92010-12-10 19:02:49 -05002684/* Should we give out recallable state?: */
2685static bool nfsd4_cb_channel_good(struct nfs4_client *clp)
2686{
2687 if (clp->cl_cb_state == NFSD4_CB_UP)
2688 return true;
2689 /*
2690 * In the sessions case, since we don't have to establish a
2691 * separate connection for callbacks, we assume it's OK
2692 * until we hear otherwise:
2693 */
2694 return clp->cl_minorversion && clp->cl_cb_state == NFSD4_CB_UNKNOWN;
2695}
2696
J. Bruce Fields22d38c42011-01-31 11:55:12 -05002697static struct file_lock *nfs4_alloc_init_lease(struct nfs4_delegation *dp, int flag)
2698{
2699 struct file_lock *fl;
2700
2701 fl = locks_alloc_lock();
2702 if (!fl)
2703 return NULL;
2704 locks_init_lock(fl);
2705 fl->fl_lmops = &nfsd_lease_mng_ops;
2706 fl->fl_flags = FL_LEASE;
2707 fl->fl_type = flag == NFS4_OPEN_DELEGATE_READ? F_RDLCK: F_WRLCK;
2708 fl->fl_end = OFFSET_MAX;
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05002709 fl->fl_owner = (fl_owner_t)(dp->dl_file);
J. Bruce Fields22d38c42011-01-31 11:55:12 -05002710 fl->fl_pid = current->tgid;
J. Bruce Fields22d38c42011-01-31 11:55:12 -05002711 return fl;
2712}
2713
J. Bruce Fieldsedab9782011-01-31 17:58:10 -05002714static int nfs4_setlease(struct nfs4_delegation *dp, int flag)
2715{
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05002716 struct nfs4_file *fp = dp->dl_file;
J. Bruce Fieldsedab9782011-01-31 17:58:10 -05002717 struct file_lock *fl;
2718 int status;
2719
2720 fl = nfs4_alloc_init_lease(dp, flag);
2721 if (!fl)
2722 return -ENOMEM;
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05002723 fl->fl_file = find_readable_file(fp);
2724 list_add(&dp->dl_perclnt, &dp->dl_client->cl_delegations);
2725 status = vfs_setlease(fl->fl_file, fl->fl_type, &fl);
J. Bruce Fieldsedab9782011-01-31 17:58:10 -05002726 if (status) {
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05002727 list_del_init(&dp->dl_perclnt);
J. Bruce Fieldsedab9782011-01-31 17:58:10 -05002728 locks_free_lock(fl);
2729 return -ENOMEM;
2730 }
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05002731 fp->fi_lease = fl;
2732 fp->fi_deleg_file = fl->fl_file;
2733 get_file(fp->fi_deleg_file);
2734 atomic_set(&fp->fi_delegees, 1);
2735 list_add(&dp->dl_perfile, &fp->fi_delegations);
2736 return 0;
2737}
2738
2739static int nfs4_set_delegation(struct nfs4_delegation *dp, int flag)
2740{
2741 struct nfs4_file *fp = dp->dl_file;
2742
2743 if (!fp->fi_lease)
2744 return nfs4_setlease(dp, flag);
2745 spin_lock(&recall_lock);
2746 if (fp->fi_had_conflict) {
2747 spin_unlock(&recall_lock);
2748 return -EAGAIN;
2749 }
2750 atomic_inc(&fp->fi_delegees);
2751 list_add(&dp->dl_perfile, &fp->fi_delegations);
2752 spin_unlock(&recall_lock);
2753 list_add(&dp->dl_perclnt, &dp->dl_client->cl_delegations);
J. Bruce Fieldsedab9782011-01-31 17:58:10 -05002754 return 0;
2755}
2756
Linus Torvalds1da177e2005-04-16 15:20:36 -07002757/*
2758 * Attempt to hand out a delegation.
2759 */
2760static void
2761nfs4_open_delegation(struct svc_fh *fh, struct nfsd4_open *open, struct nfs4_stateid *stp)
2762{
2763 struct nfs4_delegation *dp;
2764 struct nfs4_stateowner *sop = stp->st_stateowner;
J. Bruce Fields14a24e92010-12-10 19:02:49 -05002765 int cb_up;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002766 int status, flag = 0;
2767
J. Bruce Fields14a24e92010-12-10 19:02:49 -05002768 cb_up = nfsd4_cb_channel_good(sop->so_client);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002769 flag = NFS4_OPEN_DELEGATE_NONE;
NeilBrown7b190fe2005-06-23 22:03:23 -07002770 open->op_recall = 0;
2771 switch (open->op_claim_type) {
2772 case NFS4_OPEN_CLAIM_PREVIOUS:
J. Bruce Fields2bf23872010-03-08 12:37:27 -05002773 if (!cb_up)
NeilBrown7b190fe2005-06-23 22:03:23 -07002774 open->op_recall = 1;
2775 flag = open->op_delegate_type;
2776 if (flag == NFS4_OPEN_DELEGATE_NONE)
2777 goto out;
2778 break;
2779 case NFS4_OPEN_CLAIM_NULL:
2780 /* Let's not give out any delegations till everyone's
2781 * had the chance to reclaim theirs.... */
J. Bruce Fieldsaf558e32007-09-06 12:34:25 -04002782 if (locks_in_grace())
NeilBrown7b190fe2005-06-23 22:03:23 -07002783 goto out;
J. Bruce Fields2bf23872010-03-08 12:37:27 -05002784 if (!cb_up || !sop->so_confirmed)
NeilBrown7b190fe2005-06-23 22:03:23 -07002785 goto out;
2786 if (open->op_share_access & NFS4_SHARE_ACCESS_WRITE)
2787 flag = NFS4_OPEN_DELEGATE_WRITE;
2788 else
2789 flag = NFS4_OPEN_DELEGATE_READ;
2790 break;
2791 default:
2792 goto out;
2793 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002794
2795 dp = alloc_init_deleg(sop->so_client, stp, fh, flag);
J. Bruce Fieldsdd239cc2011-01-31 17:14:55 -05002796 if (dp == NULL)
2797 goto out_no_deleg;
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05002798 status = nfs4_set_delegation(dp, flag);
J. Bruce Fieldsedab9782011-01-31 17:58:10 -05002799 if (status)
J. Bruce Fieldsdd239cc2011-01-31 17:14:55 -05002800 goto out_free;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002801
2802 memcpy(&open->op_delegate_stateid, &dp->dl_stateid, sizeof(dp->dl_stateid));
2803
Benny Halevy8c10cbd2009-10-19 12:04:53 +02002804 dprintk("NFSD: delegation stateid=" STATEID_FMT "\n",
2805 STATEID_VAL(&dp->dl_stateid));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002806out:
NeilBrown7b190fe2005-06-23 22:03:23 -07002807 if (open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS
2808 && flag == NFS4_OPEN_DELEGATE_NONE
2809 && open->op_delegate_type != NFS4_OPEN_DELEGATE_NONE)
J. Bruce Fields2fdada02007-07-27 16:10:37 -04002810 dprintk("NFSD: WARNING: refusing delegation reclaim\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002811 open->op_delegate_type = flag;
J. Bruce Fieldsdd239cc2011-01-31 17:14:55 -05002812 return;
2813out_free:
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05002814 nfs4_put_delegation(dp);
J. Bruce Fieldsdd239cc2011-01-31 17:14:55 -05002815out_no_deleg:
2816 flag = NFS4_OPEN_DELEGATE_NONE;
2817 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002818}
2819
2820/*
2821 * called with nfs4_lock_state() held.
2822 */
Al Virob37ad282006-10-19 23:28:59 -07002823__be32
Linus Torvalds1da177e2005-04-16 15:20:36 -07002824nfsd4_process_open2(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_open *open)
2825{
Andy Adamson66689582009-04-03 08:28:45 +03002826 struct nfsd4_compoundres *resp = rqstp->rq_resp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002827 struct nfs4_file *fp = NULL;
2828 struct inode *ino = current_fh->fh_dentry->d_inode;
2829 struct nfs4_stateid *stp = NULL;
NeilBrown567d9822005-06-23 22:02:53 -07002830 struct nfs4_delegation *dp = NULL;
Al Virob37ad282006-10-19 23:28:59 -07002831 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002832
2833 status = nfserr_inval;
Andy Adamsond87a8ad2009-04-03 08:28:53 +03002834 if (!access_valid(open->op_share_access, resp->cstate.minorversion)
J. Bruce Fieldsba5a6a12006-06-30 01:56:16 -07002835 || !deny_valid(open->op_share_deny))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002836 goto out;
2837 /*
2838 * Lookup file; if found, lookup stateid and check open request,
2839 * and check for delegations in the process of being recalled.
2840 * If not found, create the nfs4_file struct
2841 */
2842 fp = find_file(ino);
2843 if (fp) {
2844 if ((status = nfs4_check_open(fp, open, &stp)))
2845 goto out;
NeilBrownc44c5ee2005-06-23 22:02:54 -07002846 status = nfs4_check_deleg(fp, open, &dp);
2847 if (status)
2848 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002849 } else {
NeilBrownc44c5ee2005-06-23 22:02:54 -07002850 status = nfserr_bad_stateid;
2851 if (open->op_claim_type == NFS4_OPEN_CLAIM_DELEGATE_CUR)
2852 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002853 status = nfserr_resource;
2854 fp = alloc_init_file(ino);
2855 if (fp == NULL)
2856 goto out;
2857 }
2858
2859 /*
2860 * OPEN the file, or upgrade an existing OPEN.
2861 * If truncate fails, the OPEN fails.
2862 */
2863 if (stp) {
2864 /* Stateid was found, this is an OPEN upgrade */
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04002865 status = nfs4_upgrade_open(rqstp, fp, current_fh, stp, open);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002866 if (status)
2867 goto out;
NeilBrown444c2c02005-07-07 17:59:22 -07002868 update_stateid(&stp->st_stateid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002869 } else {
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04002870 status = nfs4_new_open(rqstp, &stp, fp, current_fh, open);
NeilBrown567d9822005-06-23 22:02:53 -07002871 if (status)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002872 goto out;
2873 init_stateid(stp, fp, open);
2874 status = nfsd4_truncate(rqstp, current_fh, open);
2875 if (status) {
J. Bruce Fields22839632009-01-11 14:27:17 -05002876 release_open_stateid(stp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002877 goto out;
2878 }
Andy Adamson66689582009-04-03 08:28:45 +03002879 if (nfsd4_has_session(&resp->cstate))
2880 update_stateid(&stp->st_stateid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002881 }
2882 memcpy(&open->op_stateid, &stp->st_stateid, sizeof(stateid_t));
2883
J. Bruce Fields4dc6ec02010-04-19 15:11:28 -04002884 if (nfsd4_has_session(&resp->cstate))
Andy Adamson66689582009-04-03 08:28:45 +03002885 open->op_stateowner->so_confirmed = 1;
2886
Linus Torvalds1da177e2005-04-16 15:20:36 -07002887 /*
2888 * Attempt to hand out a delegation. No error return, because the
2889 * OPEN succeeds even if we fail.
2890 */
2891 nfs4_open_delegation(current_fh, open, stp);
2892
2893 status = nfs_ok;
2894
Benny Halevy8c10cbd2009-10-19 12:04:53 +02002895 dprintk("%s: stateid=" STATEID_FMT "\n", __func__,
2896 STATEID_VAL(&stp->st_stateid));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002897out:
NeilBrown13cd2182005-06-23 22:03:10 -07002898 if (fp)
2899 put_nfs4_file(fp);
NeilBrown37515172005-07-07 17:59:16 -07002900 if (status == 0 && open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS)
2901 nfs4_set_claim_prev(open);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002902 /*
2903 * To finish the open response, we just need to set the rflags.
2904 */
2905 open->op_rflags = NFS4_OPEN_RESULT_LOCKTYPE_POSIX;
Andy Adamson66689582009-04-03 08:28:45 +03002906 if (!open->op_stateowner->so_confirmed &&
2907 !nfsd4_has_session(&resp->cstate))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002908 open->op_rflags |= NFS4_OPEN_RESULT_CONFIRM;
2909
2910 return status;
2911}
2912
Al Virob37ad282006-10-19 23:28:59 -07002913__be32
J.Bruce Fieldsb5914802006-12-13 00:35:38 -08002914nfsd4_renew(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
2915 clientid_t *clid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002916{
2917 struct nfs4_client *clp;
Al Virob37ad282006-10-19 23:28:59 -07002918 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002919
2920 nfs4_lock_state();
2921 dprintk("process_renew(%08x/%08x): starting\n",
2922 clid->cl_boot, clid->cl_id);
2923 status = nfserr_stale_clientid;
2924 if (STALE_CLIENTID(clid))
2925 goto out;
2926 clp = find_confirmed_client(clid);
2927 status = nfserr_expired;
2928 if (clp == NULL) {
2929 /* We assume the client took too long to RENEW. */
2930 dprintk("nfsd4_renew: clientid not found!\n");
2931 goto out;
2932 }
2933 renew_client(clp);
2934 status = nfserr_cb_path_down;
NeilBrownea1da632005-06-23 22:04:17 -07002935 if (!list_empty(&clp->cl_delegations)
J. Bruce Fields77a35692010-04-30 18:51:44 -04002936 && clp->cl_cb_state != NFSD4_CB_UP)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002937 goto out;
2938 status = nfs_ok;
2939out:
2940 nfs4_unlock_state();
2941 return status;
2942}
2943
Daniel Mackc47d8322011-05-16 16:38:14 +02002944static struct lock_manager nfsd4_manager = {
J. Bruce Fieldsaf558e32007-09-06 12:34:25 -04002945};
2946
NeilBrowna76b4312005-06-23 22:04:01 -07002947static void
J. Bruce Fieldsaf558e32007-09-06 12:34:25 -04002948nfsd4_end_grace(void)
NeilBrowna76b4312005-06-23 22:04:01 -07002949{
2950 dprintk("NFSD: end of grace period\n");
NeilBrownc7b9a452005-06-23 22:04:30 -07002951 nfsd4_recdir_purge_old();
J. Bruce Fieldsaf558e32007-09-06 12:34:25 -04002952 locks_end_grace(&nfsd4_manager);
J. Bruce Fieldse46b4982010-03-01 19:21:21 -05002953 /*
2954 * Now that every NFSv4 client has had the chance to recover and
2955 * to see the (possibly new, possibly shorter) lease time, we
2956 * can safely set the next grace time to the current lease time:
2957 */
2958 nfsd4_grace = nfsd4_lease;
NeilBrowna76b4312005-06-23 22:04:01 -07002959}
2960
NeilBrownfd39ca92005-06-23 22:04:03 -07002961static time_t
Linus Torvalds1da177e2005-04-16 15:20:36 -07002962nfs4_laundromat(void)
2963{
2964 struct nfs4_client *clp;
2965 struct nfs4_stateowner *sop;
2966 struct nfs4_delegation *dp;
2967 struct list_head *pos, *next, reaplist;
J. Bruce Fieldscf07d2e2010-02-28 23:20:19 -05002968 time_t cutoff = get_seconds() - nfsd4_lease;
2969 time_t t, clientid_val = nfsd4_lease;
2970 time_t u, test_val = nfsd4_lease;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002971
2972 nfs4_lock_state();
2973
2974 dprintk("NFSD: laundromat service - starting\n");
J. Bruce Fieldsaf558e32007-09-06 12:34:25 -04002975 if (locks_in_grace())
2976 nfsd4_end_grace();
Benny Halevy36acb662010-05-12 00:13:04 +03002977 INIT_LIST_HEAD(&reaplist);
2978 spin_lock(&client_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002979 list_for_each_safe(pos, next, &client_lru) {
2980 clp = list_entry(pos, struct nfs4_client, cl_lru);
2981 if (time_after((unsigned long)clp->cl_time, (unsigned long)cutoff)) {
2982 t = clp->cl_time - cutoff;
2983 if (clientid_val > t)
2984 clientid_val = t;
2985 break;
2986 }
Benny Halevyd7682982010-05-12 00:13:54 +03002987 if (atomic_read(&clp->cl_refcount)) {
2988 dprintk("NFSD: client in use (clientid %08x)\n",
2989 clp->cl_clientid.cl_id);
2990 continue;
2991 }
2992 unhash_client_locked(clp);
2993 list_add(&clp->cl_lru, &reaplist);
Benny Halevy36acb662010-05-12 00:13:04 +03002994 }
2995 spin_unlock(&client_lock);
2996 list_for_each_safe(pos, next, &reaplist) {
2997 clp = list_entry(pos, struct nfs4_client, cl_lru);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002998 dprintk("NFSD: purging unused client (clientid %08x)\n",
2999 clp->cl_clientid.cl_id);
NeilBrownc7b9a452005-06-23 22:04:30 -07003000 nfsd4_remove_clid_dir(clp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003001 expire_client(clp);
3002 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003003 spin_lock(&recall_lock);
3004 list_for_each_safe(pos, next, &del_recall_lru) {
3005 dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
3006 if (time_after((unsigned long)dp->dl_time, (unsigned long)cutoff)) {
3007 u = dp->dl_time - cutoff;
3008 if (test_val > u)
3009 test_val = u;
3010 break;
3011 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003012 list_move(&dp->dl_recall_lru, &reaplist);
3013 }
3014 spin_unlock(&recall_lock);
3015 list_for_each_safe(pos, next, &reaplist) {
3016 dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
3017 list_del_init(&dp->dl_recall_lru);
3018 unhash_delegation(dp);
3019 }
J. Bruce Fieldscf07d2e2010-02-28 23:20:19 -05003020 test_val = nfsd4_lease;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003021 list_for_each_safe(pos, next, &close_lru) {
3022 sop = list_entry(pos, struct nfs4_stateowner, so_close_lru);
3023 if (time_after((unsigned long)sop->so_time, (unsigned long)cutoff)) {
3024 u = sop->so_time - cutoff;
3025 if (test_val > u)
3026 test_val = u;
3027 break;
3028 }
3029 dprintk("NFSD: purging unused open stateowner (so_id %d)\n",
3030 sop->so_id);
J. Bruce Fieldsf044ff82009-01-11 15:24:04 -05003031 release_openowner(sop);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003032 }
3033 if (clientid_val < NFSD_LAUNDROMAT_MINTIMEOUT)
3034 clientid_val = NFSD_LAUNDROMAT_MINTIMEOUT;
3035 nfs4_unlock_state();
3036 return clientid_val;
3037}
3038
Harvey Harrisona254b242008-02-20 12:49:00 -08003039static struct workqueue_struct *laundry_wq;
3040static void laundromat_main(struct work_struct *);
3041static DECLARE_DELAYED_WORK(laundromat_work, laundromat_main);
3042
3043static void
David Howellsc4028952006-11-22 14:57:56 +00003044laundromat_main(struct work_struct *not_used)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003045{
3046 time_t t;
3047
3048 t = nfs4_laundromat();
3049 dprintk("NFSD: laundromat_main - sleeping for %ld seconds\n", t);
NeilBrown58da2822005-06-23 22:03:19 -07003050 queue_delayed_work(laundry_wq, &laundromat_work, t*HZ);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003051}
3052
NeilBrownfd39ca92005-06-23 22:04:03 -07003053static struct nfs4_stateowner *
NeilBrownf8816512005-07-07 17:59:25 -07003054search_close_lru(u32 st_id, int flags)
3055{
Linus Torvalds1da177e2005-04-16 15:20:36 -07003056 struct nfs4_stateowner *local = NULL;
3057
Linus Torvalds1da177e2005-04-16 15:20:36 -07003058 if (flags & CLOSE_STATE) {
3059 list_for_each_entry(local, &close_lru, so_close_lru) {
3060 if (local->so_id == st_id)
3061 return local;
3062 }
3063 }
3064 return NULL;
3065}
3066
3067static inline int
3068nfs4_check_fh(struct svc_fh *fhp, struct nfs4_stateid *stp)
3069{
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04003070 return fhp->fh_dentry->d_inode != stp->st_file->fi_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003071}
3072
3073static int
3074STALE_STATEID(stateid_t *stateid)
3075{
J. Bruce Fieldse4e83ea2010-04-22 16:21:39 -04003076 if (stateid->si_boot == boot_time)
3077 return 0;
3078 dprintk("NFSD: stale stateid " STATEID_FMT "!\n",
Benny Halevy8c10cbd2009-10-19 12:04:53 +02003079 STATEID_VAL(stateid));
J. Bruce Fieldse4e83ea2010-04-22 16:21:39 -04003080 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003081}
3082
3083static inline int
3084access_permit_read(unsigned long access_bmap)
3085{
3086 return test_bit(NFS4_SHARE_ACCESS_READ, &access_bmap) ||
3087 test_bit(NFS4_SHARE_ACCESS_BOTH, &access_bmap) ||
3088 test_bit(NFS4_SHARE_ACCESS_WRITE, &access_bmap);
3089}
3090
3091static inline int
3092access_permit_write(unsigned long access_bmap)
3093{
3094 return test_bit(NFS4_SHARE_ACCESS_WRITE, &access_bmap) ||
3095 test_bit(NFS4_SHARE_ACCESS_BOTH, &access_bmap);
3096}
3097
3098static
Al Virob37ad282006-10-19 23:28:59 -07003099__be32 nfs4_check_openmode(struct nfs4_stateid *stp, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003100{
Al Virob37ad282006-10-19 23:28:59 -07003101 __be32 status = nfserr_openmode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003102
J. Bruce Fields02921912010-07-29 15:16:59 -04003103 /* For lock stateid's, we test the parent open, not the lock: */
3104 if (stp->st_openstp)
3105 stp = stp->st_openstp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003106 if ((flags & WR_STATE) && (!access_permit_write(stp->st_access_bmap)))
3107 goto out;
3108 if ((flags & RD_STATE) && (!access_permit_read(stp->st_access_bmap)))
3109 goto out;
3110 status = nfs_ok;
3111out:
3112 return status;
3113}
3114
Al Virob37ad282006-10-19 23:28:59 -07003115static inline __be32
Linus Torvalds1da177e2005-04-16 15:20:36 -07003116check_special_stateids(svc_fh *current_fh, stateid_t *stateid, int flags)
3117{
J. Bruce Fields203a8c82009-02-21 13:29:14 -08003118 if (ONE_STATEID(stateid) && (flags & RD_STATE))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003119 return nfs_ok;
J. Bruce Fieldsaf558e32007-09-06 12:34:25 -04003120 else if (locks_in_grace()) {
Lucas De Marchi25985ed2011-03-30 22:57:33 -03003121 /* Answer in remaining cases depends on existence of
Linus Torvalds1da177e2005-04-16 15:20:36 -07003122 * conflicting state; so we must wait out the grace period. */
3123 return nfserr_grace;
3124 } else if (flags & WR_STATE)
3125 return nfs4_share_conflict(current_fh,
3126 NFS4_SHARE_DENY_WRITE);
3127 else /* (flags & RD_STATE) && ZERO_STATEID(stateid) */
3128 return nfs4_share_conflict(current_fh,
3129 NFS4_SHARE_DENY_READ);
3130}
3131
3132/*
3133 * Allow READ/WRITE during grace period on recovered state only for files
3134 * that are not able to provide mandatory locking.
3135 */
3136static inline int
J. Bruce Fields18f82732009-02-21 15:23:01 -08003137grace_disallows_io(struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003138{
J. Bruce Fields203a8c82009-02-21 13:29:14 -08003139 return locks_in_grace() && mandatory_lock(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003140}
3141
Andy Adamson66689582009-04-03 08:28:45 +03003142static int check_stateid_generation(stateid_t *in, stateid_t *ref, int flags)
J. Bruce Fields0836f582008-01-26 19:08:12 -05003143{
Andy Adamson66689582009-04-03 08:28:45 +03003144 /*
3145 * When sessions are used the stateid generation number is ignored
3146 * when it is zero.
3147 */
3148 if ((flags & HAS_SESSION) && in->si_generation == 0)
3149 goto out;
3150
J. Bruce Fields0836f582008-01-26 19:08:12 -05003151 /* If the client sends us a stateid from the future, it's buggy: */
3152 if (in->si_generation > ref->si_generation)
3153 return nfserr_bad_stateid;
3154 /*
3155 * The following, however, can happen. For example, if the
3156 * client sends an open and some IO at the same time, the open
3157 * may bump si_generation while the IO is still in flight.
3158 * Thanks to hard links and renames, the client never knows what
3159 * file an open will affect. So it could avoid that situation
3160 * only by serializing all opens and IO from the same open
3161 * owner. To recover from the old_stateid error, the client
3162 * will just have to retry the IO:
3163 */
3164 if (in->si_generation < ref->si_generation)
3165 return nfserr_old_stateid;
Andy Adamson66689582009-04-03 08:28:45 +03003166out:
J. Bruce Fields0836f582008-01-26 19:08:12 -05003167 return nfs_ok;
3168}
3169
J. Bruce Fields3e633072009-02-21 13:17:19 -08003170static int is_delegation_stateid(stateid_t *stateid)
3171{
3172 return stateid->si_fileid == 0;
3173}
3174
Bryan Schumakere1ca12d2011-07-13 11:04:21 -04003175static int is_open_stateid(struct nfs4_stateid *stateid)
3176{
3177 return stateid->st_openstp == NULL;
3178}
3179
Bryan Schumaker17456802011-07-13 10:50:48 -04003180__be32 nfs4_validate_stateid(stateid_t *stateid, int flags)
3181{
3182 struct nfs4_stateid *stp = NULL;
3183 __be32 status = nfserr_stale_stateid;
3184
3185 if (STALE_STATEID(stateid))
3186 goto out;
3187
3188 status = nfserr_expired;
3189 stp = search_for_stateid(stateid);
3190 if (!stp)
3191 goto out;
3192 status = nfserr_bad_stateid;
3193
3194 if (!stp->st_stateowner->so_confirmed)
3195 goto out;
3196
3197 status = check_stateid_generation(stateid, &stp->st_stateid, flags);
3198 if (status)
3199 goto out;
3200
3201 status = nfs_ok;
3202out:
3203 return status;
3204}
3205
Linus Torvalds1da177e2005-04-16 15:20:36 -07003206/*
3207* Checks for stateid operations
3208*/
Al Virob37ad282006-10-19 23:28:59 -07003209__be32
Benny Halevydd453df2009-04-03 08:28:41 +03003210nfs4_preprocess_stateid_op(struct nfsd4_compound_state *cstate,
3211 stateid_t *stateid, int flags, struct file **filpp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003212{
3213 struct nfs4_stateid *stp = NULL;
3214 struct nfs4_delegation *dp = NULL;
Benny Halevydd453df2009-04-03 08:28:41 +03003215 struct svc_fh *current_fh = &cstate->current_fh;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003216 struct inode *ino = current_fh->fh_dentry->d_inode;
Al Virob37ad282006-10-19 23:28:59 -07003217 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003218
Linus Torvalds1da177e2005-04-16 15:20:36 -07003219 if (filpp)
3220 *filpp = NULL;
3221
J. Bruce Fields18f82732009-02-21 15:23:01 -08003222 if (grace_disallows_io(ino))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003223 return nfserr_grace;
3224
Andy Adamson66689582009-04-03 08:28:45 +03003225 if (nfsd4_has_session(cstate))
3226 flags |= HAS_SESSION;
3227
Linus Torvalds1da177e2005-04-16 15:20:36 -07003228 if (ZERO_STATEID(stateid) || ONE_STATEID(stateid))
3229 return check_special_stateids(current_fh, stateid, flags);
3230
Linus Torvalds1da177e2005-04-16 15:20:36 -07003231 status = nfserr_stale_stateid;
3232 if (STALE_STATEID(stateid))
3233 goto out;
3234
J. Bruce Fields33515142010-10-02 18:42:39 -04003235 /*
3236 * We assume that any stateid that has the current boot time,
3237 * but that we can't find, is expired:
3238 */
3239 status = nfserr_expired;
J. Bruce Fields3e633072009-02-21 13:17:19 -08003240 if (is_delegation_stateid(stateid)) {
J. Bruce Fieldsa4455be2009-02-21 10:40:22 -08003241 dp = find_delegation_stateid(ino, stateid);
J. Bruce Fieldse4e83ea2010-04-22 16:21:39 -04003242 if (!dp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003243 goto out;
Andy Adamson66689582009-04-03 08:28:45 +03003244 status = check_stateid_generation(stateid, &dp->dl_stateid,
3245 flags);
J. Bruce Fields0c2a4982009-02-21 11:11:50 -08003246 if (status)
3247 goto out;
J. Bruce Fieldsdc9bf702009-02-21 11:14:43 -08003248 status = nfs4_check_delegmode(dp, flags);
3249 if (status)
3250 goto out;
3251 renew_client(dp->dl_client);
Dan Carpenter43b01782010-10-27 23:19:04 +02003252 if (filpp) {
J. Bruce Fieldsacfdf5c2011-01-31 19:20:39 -05003253 *filpp = dp->dl_file->fi_deleg_file;
Dan Carpenter43b01782010-10-27 23:19:04 +02003254 BUG_ON(!*filpp);
3255 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003256 } else { /* open or lock stateid */
J. Bruce Fieldsa4455be2009-02-21 10:40:22 -08003257 stp = find_stateid(stateid, flags);
J. Bruce Fieldse4e83ea2010-04-22 16:21:39 -04003258 if (!stp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003259 goto out;
J. Bruce Fields33515142010-10-02 18:42:39 -04003260 status = nfserr_bad_stateid;
J. Bruce Fields6150ef02009-02-21 13:36:16 -08003261 if (nfs4_check_fh(current_fh, stp))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003262 goto out;
3263 if (!stp->st_stateowner->so_confirmed)
3264 goto out;
Andy Adamson66689582009-04-03 08:28:45 +03003265 status = check_stateid_generation(stateid, &stp->st_stateid,
3266 flags);
J. Bruce Fields0c2a4982009-02-21 11:11:50 -08003267 if (status)
3268 goto out;
J. Bruce Fieldsa4455be2009-02-21 10:40:22 -08003269 status = nfs4_check_openmode(stp, flags);
3270 if (status)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003271 goto out;
3272 renew_client(stp->st_stateowner->so_client);
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04003273 if (filpp) {
3274 if (flags & RD_STATE)
3275 *filpp = find_readable_file(stp->st_file);
3276 else
3277 *filpp = find_writeable_file(stp->st_file);
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04003278 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003279 }
3280 status = nfs_ok;
3281out:
3282 return status;
3283}
3284
Bryan Schumakere1ca12d2011-07-13 11:04:21 -04003285static __be32
3286nfsd4_free_delegation_stateid(stateid_t *stateid)
3287{
3288 struct nfs4_delegation *dp = search_for_delegation(stateid);
3289 if (dp)
3290 return nfserr_locks_held;
3291 return nfserr_bad_stateid;
3292}
3293
3294static __be32
3295nfsd4_free_lock_stateid(struct nfs4_stateid *stp)
3296{
3297 if (check_for_locks(stp->st_file, stp->st_stateowner))
3298 return nfserr_locks_held;
3299 release_lock_stateid(stp);
3300 return nfs_ok;
3301}
3302
3303/*
Bryan Schumaker17456802011-07-13 10:50:48 -04003304 * Test if the stateid is valid
3305 */
3306__be32
3307nfsd4_test_stateid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
3308 struct nfsd4_test_stateid *test_stateid)
3309{
3310 test_stateid->ts_has_session = nfsd4_has_session(cstate);
3311 return nfs_ok;
3312}
3313
3314/*
Bryan Schumakere1ca12d2011-07-13 11:04:21 -04003315 * Free a state id
3316 */
3317__be32
3318nfsd4_free_stateid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
3319 struct nfsd4_free_stateid *free_stateid)
3320{
3321 stateid_t *stateid = &free_stateid->fr_stateid;
3322 struct nfs4_stateid *stp;
3323 __be32 ret;
3324
3325 nfs4_lock_state();
3326 if (is_delegation_stateid(stateid)) {
3327 ret = nfsd4_free_delegation_stateid(stateid);
3328 goto out;
3329 }
3330
3331 stp = search_for_stateid(stateid);
3332 if (!stp) {
3333 ret = nfserr_bad_stateid;
3334 goto out;
3335 }
3336 if (stateid->si_generation != 0) {
3337 if (stateid->si_generation < stp->st_stateid.si_generation) {
3338 ret = nfserr_old_stateid;
3339 goto out;
3340 }
3341 if (stateid->si_generation > stp->st_stateid.si_generation) {
3342 ret = nfserr_bad_stateid;
3343 goto out;
3344 }
3345 }
3346
3347 if (is_open_stateid(stp)) {
3348 ret = nfserr_locks_held;
3349 goto out;
3350 } else {
3351 ret = nfsd4_free_lock_stateid(stp);
3352 goto out;
3353 }
3354
3355out:
3356 nfs4_unlock_state();
3357 return ret;
3358}
3359
NeilBrown4c4cd222005-07-07 17:59:27 -07003360static inline int
3361setlkflg (int type)
3362{
3363 return (type == NFS4_READW_LT || type == NFS4_READ_LT) ?
3364 RD_STATE : WR_STATE;
3365}
Linus Torvalds1da177e2005-04-16 15:20:36 -07003366
3367/*
3368 * Checks for sequence id mutating operations.
3369 */
Al Virob37ad282006-10-19 23:28:59 -07003370static __be32
Benny Halevydd453df2009-04-03 08:28:41 +03003371nfs4_preprocess_seqid_op(struct nfsd4_compound_state *cstate, u32 seqid,
3372 stateid_t *stateid, int flags,
3373 struct nfs4_stateowner **sopp,
3374 struct nfs4_stateid **stpp, struct nfsd4_lock *lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003375{
Linus Torvalds1da177e2005-04-16 15:20:36 -07003376 struct nfs4_stateid *stp;
3377 struct nfs4_stateowner *sop;
Benny Halevydd453df2009-04-03 08:28:41 +03003378 struct svc_fh *current_fh = &cstate->current_fh;
J. Bruce Fields0836f582008-01-26 19:08:12 -05003379 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003380
Benny Halevy8c10cbd2009-10-19 12:04:53 +02003381 dprintk("NFSD: %s: seqid=%d stateid = " STATEID_FMT "\n", __func__,
3382 seqid, STATEID_VAL(stateid));
NeilBrown3a4f98b2005-07-07 17:59:26 -07003383
Linus Torvalds1da177e2005-04-16 15:20:36 -07003384 *stpp = NULL;
3385 *sopp = NULL;
3386
Linus Torvalds1da177e2005-04-16 15:20:36 -07003387 if (ZERO_STATEID(stateid) || ONE_STATEID(stateid)) {
J. Bruce Fields2fdada02007-07-27 16:10:37 -04003388 dprintk("NFSD: preprocess_seqid_op: magic stateid!\n");
NeilBrown3a4f98b2005-07-07 17:59:26 -07003389 return nfserr_bad_stateid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003390 }
3391
Linus Torvalds1da177e2005-04-16 15:20:36 -07003392 if (STALE_STATEID(stateid))
NeilBrown3a4f98b2005-07-07 17:59:26 -07003393 return nfserr_stale_stateid;
Andy Adamson66689582009-04-03 08:28:45 +03003394
3395 if (nfsd4_has_session(cstate))
3396 flags |= HAS_SESSION;
3397
Linus Torvalds1da177e2005-04-16 15:20:36 -07003398 /*
3399 * We return BAD_STATEID if filehandle doesn't match stateid,
3400 * the confirmed flag is incorrecly set, or the generation
3401 * number is incorrect.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003402 */
NeilBrownf8816512005-07-07 17:59:25 -07003403 stp = find_stateid(stateid, flags);
3404 if (stp == NULL) {
3405 /*
3406 * Also, we should make sure this isn't just the result of
3407 * a replayed close:
3408 */
3409 sop = search_close_lru(stateid->si_stateownerid, flags);
J. Bruce Fields33515142010-10-02 18:42:39 -04003410 /* It's not stale; let's assume it's expired: */
NeilBrownf8816512005-07-07 17:59:25 -07003411 if (sop == NULL)
J. Bruce Fields33515142010-10-02 18:42:39 -04003412 return nfserr_expired;
NeilBrownf8816512005-07-07 17:59:25 -07003413 *sopp = sop;
3414 goto check_replay;
3415 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003416
J. Bruce Fields39325bd2007-11-26 17:06:39 -05003417 *stpp = stp;
3418 *sopp = sop = stp->st_stateowner;
3419
NeilBrown4c4cd222005-07-07 17:59:27 -07003420 if (lock) {
NeilBrown4c4cd222005-07-07 17:59:27 -07003421 clientid_t *lockclid = &lock->v.new.clientid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003422 struct nfs4_client *clp = sop->so_client;
NeilBrown4c4cd222005-07-07 17:59:27 -07003423 int lkflg = 0;
Al Virob37ad282006-10-19 23:28:59 -07003424 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003425
NeilBrown4c4cd222005-07-07 17:59:27 -07003426 lkflg = setlkflg(lock->lk_type);
3427
3428 if (lock->lk_is_new) {
J. Bruce Fields599e0a22007-07-26 17:04:54 -04003429 if (!sop->so_is_open_owner)
3430 return nfserr_bad_stateid;
Andy Adamson60adfc52009-04-03 08:28:50 +03003431 if (!(flags & HAS_SESSION) &&
3432 !same_clid(&clp->cl_clientid, lockclid))
3433 return nfserr_bad_stateid;
J. Bruce Fields599e0a22007-07-26 17:04:54 -04003434 /* stp is the open stateid */
3435 status = nfs4_check_openmode(stp, lkflg);
3436 if (status)
3437 return status;
3438 } else {
3439 /* stp is the lock stateid */
3440 status = nfs4_check_openmode(stp->st_openstp, lkflg);
3441 if (status)
3442 return status;
NeilBrown4c4cd222005-07-07 17:59:27 -07003443 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003444 }
3445
J. Bruce Fieldsf3362732008-01-26 14:58:45 -05003446 if (nfs4_check_fh(current_fh, stp)) {
J. Bruce Fields2fdada02007-07-27 16:10:37 -04003447 dprintk("NFSD: preprocess_seqid_op: fh-stateid mismatch!\n");
NeilBrown3a4f98b2005-07-07 17:59:26 -07003448 return nfserr_bad_stateid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003449 }
3450
Linus Torvalds1da177e2005-04-16 15:20:36 -07003451 /*
3452 * We now validate the seqid and stateid generation numbers.
3453 * For the moment, we ignore the possibility of
3454 * generation number wraparound.
3455 */
Andy Adamson66689582009-04-03 08:28:45 +03003456 if (!(flags & HAS_SESSION) && seqid != sop->so_seqid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003457 goto check_replay;
3458
NeilBrown3a4f98b2005-07-07 17:59:26 -07003459 if (sop->so_confirmed && flags & CONFIRM) {
J. Bruce Fields2fdada02007-07-27 16:10:37 -04003460 dprintk("NFSD: preprocess_seqid_op: expected"
NeilBrown3a4f98b2005-07-07 17:59:26 -07003461 " unconfirmed stateowner!\n");
3462 return nfserr_bad_stateid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003463 }
NeilBrown3a4f98b2005-07-07 17:59:26 -07003464 if (!sop->so_confirmed && !(flags & CONFIRM)) {
J. Bruce Fields2fdada02007-07-27 16:10:37 -04003465 dprintk("NFSD: preprocess_seqid_op: stateowner not"
NeilBrown3a4f98b2005-07-07 17:59:26 -07003466 " confirmed yet!\n");
3467 return nfserr_bad_stateid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003468 }
Andy Adamson66689582009-04-03 08:28:45 +03003469 status = check_stateid_generation(stateid, &stp->st_stateid, flags);
J. Bruce Fields0836f582008-01-26 19:08:12 -05003470 if (status)
3471 return status;
NeilBrown52fd0042005-07-07 17:59:24 -07003472 renew_client(sop->so_client);
NeilBrown3a4f98b2005-07-07 17:59:26 -07003473 return nfs_ok;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003474
Linus Torvalds1da177e2005-04-16 15:20:36 -07003475check_replay:
NeilBrownbd9aac52005-07-07 17:59:19 -07003476 if (seqid == sop->so_seqid - 1) {
Neil Brown849823c2005-09-13 01:25:36 -07003477 dprintk("NFSD: preprocess_seqid_op: retransmission?\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003478 /* indicate replay to calling function */
Al Viroa90b0612006-10-19 23:29:03 -07003479 return nfserr_replay_me;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003480 }
J. Bruce Fields2fdada02007-07-27 16:10:37 -04003481 dprintk("NFSD: preprocess_seqid_op: bad seqid (expected %d, got %d)\n",
NeilBrown3a4f98b2005-07-07 17:59:26 -07003482 sop->so_seqid, seqid);
3483 *sopp = NULL;
3484 return nfserr_bad_seqid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003485}
3486
Al Virob37ad282006-10-19 23:28:59 -07003487__be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003488nfsd4_open_confirm(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
J.Bruce Fieldsa4f1706a92006-12-13 00:35:28 -08003489 struct nfsd4_open_confirm *oc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003490{
Al Virob37ad282006-10-19 23:28:59 -07003491 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003492 struct nfs4_stateowner *sop;
3493 struct nfs4_stateid *stp;
3494
3495 dprintk("NFSD: nfsd4_open_confirm on file %.*s\n",
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003496 (int)cstate->current_fh.fh_dentry->d_name.len,
3497 cstate->current_fh.fh_dentry->d_name.name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003498
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003499 status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0);
J. Bruce Fieldsa8cddc52006-06-30 01:56:13 -07003500 if (status)
3501 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003502
3503 nfs4_lock_state();
3504
Benny Halevydd453df2009-04-03 08:28:41 +03003505 if ((status = nfs4_preprocess_seqid_op(cstate,
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003506 oc->oc_seqid, &oc->oc_req_stateid,
J. Bruce Fieldsf3362732008-01-26 14:58:45 -05003507 CONFIRM | OPEN_STATE,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003508 &oc->oc_stateowner, &stp, NULL)))
3509 goto out;
3510
3511 sop = oc->oc_stateowner;
3512 sop->so_confirmed = 1;
3513 update_stateid(&stp->st_stateid);
3514 memcpy(&oc->oc_resp_stateid, &stp->st_stateid, sizeof(stateid_t));
Benny Halevy8c10cbd2009-10-19 12:04:53 +02003515 dprintk("NFSD: %s: success, seqid=%d stateid=" STATEID_FMT "\n",
3516 __func__, oc->oc_seqid, STATEID_VAL(&stp->st_stateid));
NeilBrownc7b9a452005-06-23 22:04:30 -07003517
3518 nfsd4_create_clid_dir(sop->so_client);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003519out:
Neil Brownf2327d92005-09-13 01:25:37 -07003520 if (oc->oc_stateowner) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003521 nfs4_get_stateowner(oc->oc_stateowner);
J.Bruce Fieldsa4f1706a92006-12-13 00:35:28 -08003522 cstate->replay_owner = oc->oc_stateowner;
Neil Brownf2327d92005-09-13 01:25:37 -07003523 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003524 nfs4_unlock_state();
3525 return status;
3526}
3527
J. Bruce Fieldsf197c272011-06-29 08:23:50 -04003528static inline void nfs4_file_downgrade(struct nfs4_stateid *stp, unsigned int to_access)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003529{
3530 int i;
J. Bruce Fieldsf197c272011-06-29 08:23:50 -04003531
Linus Torvalds1da177e2005-04-16 15:20:36 -07003532 for (i = 1; i < 4; i++) {
J. Bruce Fieldsf197c272011-06-29 08:23:50 -04003533 if (test_bit(i, &stp->st_access_bmap) && !(i & to_access)) {
3534 nfs4_file_put_access(stp->st_file, i);
3535 __clear_bit(i, &stp->st_access_bmap);
3536 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003537 }
3538}
3539
3540static void
3541reset_union_bmap_deny(unsigned long deny, unsigned long *bmap)
3542{
3543 int i;
3544 for (i = 0; i < 4; i++) {
3545 if ((i & deny) != i)
3546 __clear_bit(i, bmap);
3547 }
3548}
3549
Al Virob37ad282006-10-19 23:28:59 -07003550__be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003551nfsd4_open_downgrade(struct svc_rqst *rqstp,
3552 struct nfsd4_compound_state *cstate,
J.Bruce Fieldsa4f1706a92006-12-13 00:35:28 -08003553 struct nfsd4_open_downgrade *od)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003554{
Al Virob37ad282006-10-19 23:28:59 -07003555 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003556 struct nfs4_stateid *stp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003557
3558 dprintk("NFSD: nfsd4_open_downgrade on file %.*s\n",
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003559 (int)cstate->current_fh.fh_dentry->d_name.len,
3560 cstate->current_fh.fh_dentry->d_name.name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003561
Andy Adamsond87a8ad2009-04-03 08:28:53 +03003562 if (!access_valid(od->od_share_access, cstate->minorversion)
J. Bruce Fieldsba5a6a12006-06-30 01:56:16 -07003563 || !deny_valid(od->od_share_deny))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003564 return nfserr_inval;
3565
3566 nfs4_lock_state();
Benny Halevydd453df2009-04-03 08:28:41 +03003567 if ((status = nfs4_preprocess_seqid_op(cstate,
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003568 od->od_seqid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003569 &od->od_stateid,
J. Bruce Fieldsf3362732008-01-26 14:58:45 -05003570 OPEN_STATE,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003571 &od->od_stateowner, &stp, NULL)))
3572 goto out;
3573
3574 status = nfserr_inval;
3575 if (!test_bit(od->od_share_access, &stp->st_access_bmap)) {
3576 dprintk("NFSD:access not a subset current bitmap: 0x%lx, input access=%08x\n",
3577 stp->st_access_bmap, od->od_share_access);
3578 goto out;
3579 }
3580 if (!test_bit(od->od_share_deny, &stp->st_deny_bmap)) {
3581 dprintk("NFSD:deny not a subset current bitmap: 0x%lx, input deny=%08x\n",
3582 stp->st_deny_bmap, od->od_share_deny);
3583 goto out;
3584 }
J. Bruce Fieldsf197c272011-06-29 08:23:50 -04003585 nfs4_file_downgrade(stp, od->od_share_access);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003586
Linus Torvalds1da177e2005-04-16 15:20:36 -07003587 reset_union_bmap_deny(od->od_share_deny, &stp->st_deny_bmap);
3588
3589 update_stateid(&stp->st_stateid);
3590 memcpy(&od->od_stateid, &stp->st_stateid, sizeof(stateid_t));
3591 status = nfs_ok;
3592out:
Neil Brownf2327d92005-09-13 01:25:37 -07003593 if (od->od_stateowner) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003594 nfs4_get_stateowner(od->od_stateowner);
J.Bruce Fieldsa4f1706a92006-12-13 00:35:28 -08003595 cstate->replay_owner = od->od_stateowner;
Neil Brownf2327d92005-09-13 01:25:37 -07003596 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003597 nfs4_unlock_state();
3598 return status;
3599}
3600
3601/*
3602 * nfs4_unlock_state() called after encode
3603 */
Al Virob37ad282006-10-19 23:28:59 -07003604__be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003605nfsd4_close(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
J.Bruce Fieldsa4f1706a92006-12-13 00:35:28 -08003606 struct nfsd4_close *close)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003607{
Al Virob37ad282006-10-19 23:28:59 -07003608 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003609 struct nfs4_stateid *stp;
3610
3611 dprintk("NFSD: nfsd4_close on file %.*s\n",
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003612 (int)cstate->current_fh.fh_dentry->d_name.len,
3613 cstate->current_fh.fh_dentry->d_name.name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003614
3615 nfs4_lock_state();
3616 /* check close_lru for replay */
Benny Halevydd453df2009-04-03 08:28:41 +03003617 if ((status = nfs4_preprocess_seqid_op(cstate,
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003618 close->cl_seqid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003619 &close->cl_stateid,
J. Bruce Fieldsf3362732008-01-26 14:58:45 -05003620 OPEN_STATE | CLOSE_STATE,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003621 &close->cl_stateowner, &stp, NULL)))
3622 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003623 status = nfs_ok;
3624 update_stateid(&stp->st_stateid);
3625 memcpy(&close->cl_stateid, &stp->st_stateid, sizeof(stateid_t));
3626
J. Bruce Fields04ef5952006-01-18 17:43:21 -08003627 /* release_stateid() calls nfsd_close() if needed */
J. Bruce Fields22839632009-01-11 14:27:17 -05003628 release_open_stateid(stp);
J. Bruce Fields04ef5952006-01-18 17:43:21 -08003629
3630 /* place unused nfs4_stateowners on so_close_lru list to be
3631 * released by the laundromat service after the lease period
3632 * to enable us to handle CLOSE replay
3633 */
3634 if (list_empty(&close->cl_stateowner->so_stateids))
3635 move_to_close_lru(close->cl_stateowner);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003636out:
Neil Brownf2327d92005-09-13 01:25:37 -07003637 if (close->cl_stateowner) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003638 nfs4_get_stateowner(close->cl_stateowner);
J.Bruce Fieldsa4f1706a92006-12-13 00:35:28 -08003639 cstate->replay_owner = close->cl_stateowner;
Neil Brownf2327d92005-09-13 01:25:37 -07003640 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003641 nfs4_unlock_state();
3642 return status;
3643}
3644
Al Virob37ad282006-10-19 23:28:59 -07003645__be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003646nfsd4_delegreturn(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
3647 struct nfsd4_delegreturn *dr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003648{
J. Bruce Fields203a8c82009-02-21 13:29:14 -08003649 struct nfs4_delegation *dp;
3650 stateid_t *stateid = &dr->dr_stateid;
3651 struct inode *inode;
Al Virob37ad282006-10-19 23:28:59 -07003652 __be32 status;
Andy Adamson66689582009-04-03 08:28:45 +03003653 int flags = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003654
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003655 if ((status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0)))
J. Bruce Fields203a8c82009-02-21 13:29:14 -08003656 return status;
3657 inode = cstate->current_fh.fh_dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003658
Andy Adamson66689582009-04-03 08:28:45 +03003659 if (nfsd4_has_session(cstate))
3660 flags |= HAS_SESSION;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003661 nfs4_lock_state();
J. Bruce Fields203a8c82009-02-21 13:29:14 -08003662 status = nfserr_bad_stateid;
3663 if (ZERO_STATEID(stateid) || ONE_STATEID(stateid))
3664 goto out;
3665 status = nfserr_stale_stateid;
3666 if (STALE_STATEID(stateid))
3667 goto out;
J. Bruce Fields7e0f7cf2009-02-21 13:32:28 -08003668 status = nfserr_bad_stateid;
J. Bruce Fields203a8c82009-02-21 13:29:14 -08003669 if (!is_delegation_stateid(stateid))
3670 goto out;
J. Bruce Fields33515142010-10-02 18:42:39 -04003671 status = nfserr_expired;
J. Bruce Fields203a8c82009-02-21 13:29:14 -08003672 dp = find_delegation_stateid(inode, stateid);
J. Bruce Fieldse4e83ea2010-04-22 16:21:39 -04003673 if (!dp)
J. Bruce Fields203a8c82009-02-21 13:29:14 -08003674 goto out;
Andy Adamson66689582009-04-03 08:28:45 +03003675 status = check_stateid_generation(stateid, &dp->dl_stateid, flags);
J. Bruce Fields203a8c82009-02-21 13:29:14 -08003676 if (status)
3677 goto out;
3678 renew_client(dp->dl_client);
3679
3680 unhash_delegation(dp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003681out:
J. Bruce Fields203a8c82009-02-21 13:29:14 -08003682 nfs4_unlock_state();
3683
Linus Torvalds1da177e2005-04-16 15:20:36 -07003684 return status;
3685}
3686
3687
3688/*
3689 * Lock owner state (byte-range locks)
3690 */
3691#define LOFF_OVERFLOW(start, len) ((u64)(len) > ~(u64)(start))
3692#define LOCK_HASH_BITS 8
3693#define LOCK_HASH_SIZE (1 << LOCK_HASH_BITS)
3694#define LOCK_HASH_MASK (LOCK_HASH_SIZE - 1)
3695
Benny Halevy87df4de2008-12-15 19:42:03 +02003696static inline u64
3697end_offset(u64 start, u64 len)
3698{
3699 u64 end;
3700
3701 end = start + len;
3702 return end >= start ? end: NFS4_MAX_UINT64;
3703}
3704
3705/* last octet in a range */
3706static inline u64
3707last_byte_offset(u64 start, u64 len)
3708{
3709 u64 end;
3710
3711 BUG_ON(!len);
3712 end = start + len;
3713 return end > start ? end - 1: NFS4_MAX_UINT64;
3714}
3715
Linus Torvalds1da177e2005-04-16 15:20:36 -07003716#define lockownerid_hashval(id) \
3717 ((id) & LOCK_HASH_MASK)
3718
3719static inline unsigned int
3720lock_ownerstr_hashval(struct inode *inode, u32 cl_id,
3721 struct xdr_netobj *ownername)
3722{
3723 return (file_hashval(inode) + cl_id
3724 + opaque_hashval(ownername->data, ownername->len))
3725 & LOCK_HASH_MASK;
3726}
3727
3728static struct list_head lock_ownerid_hashtbl[LOCK_HASH_SIZE];
3729static struct list_head lock_ownerstr_hashtbl[LOCK_HASH_SIZE];
3730static struct list_head lockstateid_hashtbl[STATEID_HASH_SIZE];
3731
Bryan Schumakere1ca12d2011-07-13 11:04:21 -04003732static int
3733same_stateid(stateid_t *id_one, stateid_t *id_two)
3734{
3735 if (id_one->si_stateownerid != id_two->si_stateownerid)
3736 return 0;
3737 return id_one->si_fileid == id_two->si_fileid;
3738}
3739
NeilBrownfd39ca92005-06-23 22:04:03 -07003740static struct nfs4_stateid *
Linus Torvalds1da177e2005-04-16 15:20:36 -07003741find_stateid(stateid_t *stid, int flags)
3742{
Krishna Kumar9346eff2008-10-20 11:44:28 +05303743 struct nfs4_stateid *local;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003744 u32 st_id = stid->si_stateownerid;
3745 u32 f_id = stid->si_fileid;
3746 unsigned int hashval;
3747
3748 dprintk("NFSD: find_stateid flags 0x%x\n",flags);
Krishna Kumar9346eff2008-10-20 11:44:28 +05303749 if (flags & (LOCK_STATE | RD_STATE | WR_STATE)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003750 hashval = stateid_hashval(st_id, f_id);
3751 list_for_each_entry(local, &lockstateid_hashtbl[hashval], st_hash) {
3752 if ((local->st_stateid.si_stateownerid == st_id) &&
3753 (local->st_stateid.si_fileid == f_id))
3754 return local;
3755 }
3756 }
Krishna Kumar9346eff2008-10-20 11:44:28 +05303757
3758 if (flags & (OPEN_STATE | RD_STATE | WR_STATE)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003759 hashval = stateid_hashval(st_id, f_id);
3760 list_for_each_entry(local, &stateid_hashtbl[hashval], st_hash) {
3761 if ((local->st_stateid.si_stateownerid == st_id) &&
3762 (local->st_stateid.si_fileid == f_id))
3763 return local;
3764 }
Neil Brown849823c2005-09-13 01:25:36 -07003765 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003766 return NULL;
3767}
3768
Bryan Schumakere1ca12d2011-07-13 11:04:21 -04003769static struct nfs4_stateid *
3770search_for_stateid(stateid_t *stid)
3771{
3772 struct nfs4_stateid *local;
3773 unsigned int hashval = stateid_hashval(stid->si_stateownerid, stid->si_fileid);
3774
3775 list_for_each_entry(local, &lockstateid_hashtbl[hashval], st_hash) {
3776 if (same_stateid(&local->st_stateid, stid))
3777 return local;
3778 }
3779
3780 list_for_each_entry(local, &stateid_hashtbl[hashval], st_hash) {
3781 if (same_stateid(&local->st_stateid, stid))
3782 return local;
3783 }
3784 return NULL;
3785}
3786
3787static struct nfs4_delegation *
3788search_for_delegation(stateid_t *stid)
3789{
3790 struct nfs4_file *fp;
3791 struct nfs4_delegation *dp;
3792 struct list_head *pos;
3793 int i;
3794
3795 for (i = 0; i < FILE_HASH_SIZE; i++) {
3796 list_for_each_entry(fp, &file_hashtbl[i], fi_hash) {
3797 list_for_each(pos, &fp->fi_delegations) {
3798 dp = list_entry(pos, struct nfs4_delegation, dl_perfile);
3799 if (same_stateid(&dp->dl_stateid, stid))
3800 return dp;
3801 }
3802 }
3803 }
3804 return NULL;
3805}
3806
Linus Torvalds1da177e2005-04-16 15:20:36 -07003807static struct nfs4_delegation *
3808find_delegation_stateid(struct inode *ino, stateid_t *stid)
3809{
NeilBrown13cd2182005-06-23 22:03:10 -07003810 struct nfs4_file *fp;
3811 struct nfs4_delegation *dl;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003812
Benny Halevy8c10cbd2009-10-19 12:04:53 +02003813 dprintk("NFSD: %s: stateid=" STATEID_FMT "\n", __func__,
3814 STATEID_VAL(stid));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003815
Linus Torvalds1da177e2005-04-16 15:20:36 -07003816 fp = find_file(ino);
NeilBrown13cd2182005-06-23 22:03:10 -07003817 if (!fp)
3818 return NULL;
3819 dl = find_delegation_file(fp, stid);
3820 put_nfs4_file(fp);
3821 return dl;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003822}
3823
3824/*
3825 * TODO: Linux file offsets are _signed_ 64-bit quantities, which means that
3826 * we can't properly handle lock requests that go beyond the (2^63 - 1)-th
3827 * byte, because of sign extension problems. Since NFSv4 calls for 64-bit
3828 * locking, this prevents us from being completely protocol-compliant. The
3829 * real solution to this problem is to start using unsigned file offsets in
3830 * the VFS, but this is a very deep change!
3831 */
3832static inline void
3833nfs4_transform_lock_offset(struct file_lock *lock)
3834{
3835 if (lock->fl_start < 0)
3836 lock->fl_start = OFFSET_MAX;
3837 if (lock->fl_end < 0)
3838 lock->fl_end = OFFSET_MAX;
3839}
3840
NeilBrownd5b90262006-04-10 22:55:22 -07003841/* Hack!: For now, we're defining this just so we can use a pointer to it
3842 * as a unique cookie to identify our (NFSv4's) posix locks. */
Alexey Dobriyan7b021962009-09-21 17:01:12 -07003843static const struct lock_manager_operations nfsd_posix_mng_ops = {
NeilBrownd5b90262006-04-10 22:55:22 -07003844};
Linus Torvalds1da177e2005-04-16 15:20:36 -07003845
3846static inline void
3847nfs4_set_lock_denied(struct file_lock *fl, struct nfsd4_lock_denied *deny)
3848{
NeilBrownd5b90262006-04-10 22:55:22 -07003849 struct nfs4_stateowner *sop;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003850
NeilBrownd5b90262006-04-10 22:55:22 -07003851 if (fl->fl_lmops == &nfsd_posix_mng_ops) {
3852 sop = (struct nfs4_stateowner *) fl->fl_owner;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003853 kref_get(&sop->so_ref);
3854 deny->ld_sop = sop;
3855 deny->ld_clientid = sop->so_client->cl_clientid;
NeilBrownd5b90262006-04-10 22:55:22 -07003856 } else {
3857 deny->ld_sop = NULL;
3858 deny->ld_clientid.cl_boot = 0;
3859 deny->ld_clientid.cl_id = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003860 }
3861 deny->ld_start = fl->fl_start;
Benny Halevy87df4de2008-12-15 19:42:03 +02003862 deny->ld_length = NFS4_MAX_UINT64;
3863 if (fl->fl_end != NFS4_MAX_UINT64)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003864 deny->ld_length = fl->fl_end - fl->fl_start + 1;
3865 deny->ld_type = NFS4_READ_LT;
3866 if (fl->fl_type != F_RDLCK)
3867 deny->ld_type = NFS4_WRITE_LT;
3868}
3869
3870static struct nfs4_stateowner *
Linus Torvalds1da177e2005-04-16 15:20:36 -07003871find_lockstateowner_str(struct inode *inode, clientid_t *clid,
3872 struct xdr_netobj *owner)
3873{
3874 unsigned int hashval = lock_ownerstr_hashval(inode, clid->cl_id, owner);
3875 struct nfs4_stateowner *op;
3876
3877 list_for_each_entry(op, &lock_ownerstr_hashtbl[hashval], so_strhash) {
J. Bruce Fields599e0a22007-07-26 17:04:54 -04003878 if (same_owner_str(op, owner, clid))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003879 return op;
3880 }
3881 return NULL;
3882}
3883
3884/*
3885 * Alloc a lock owner structure.
3886 * Called in nfsd4_lock - therefore, OPEN and OPEN_CONFIRM (if needed) has
Lucas De Marchi25985ed2011-03-30 22:57:33 -03003887 * occurred.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003888 *
3889 * strhashval = lock_ownerstr_hashval
Linus Torvalds1da177e2005-04-16 15:20:36 -07003890 */
3891
3892static struct nfs4_stateowner *
3893alloc_init_lock_stateowner(unsigned int strhashval, struct nfs4_client *clp, struct nfs4_stateid *open_stp, struct nfsd4_lock *lock) {
3894 struct nfs4_stateowner *sop;
3895 struct nfs4_replay *rp;
3896 unsigned int idhashval;
3897
3898 if (!(sop = alloc_stateowner(&lock->lk_new_owner)))
3899 return NULL;
3900 idhashval = lockownerid_hashval(current_ownerid);
3901 INIT_LIST_HEAD(&sop->so_idhash);
3902 INIT_LIST_HEAD(&sop->so_strhash);
3903 INIT_LIST_HEAD(&sop->so_perclient);
NeilBrownea1da632005-06-23 22:04:17 -07003904 INIT_LIST_HEAD(&sop->so_stateids);
3905 INIT_LIST_HEAD(&sop->so_perstateid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003906 INIT_LIST_HEAD(&sop->so_close_lru); /* not used */
3907 sop->so_time = 0;
3908 list_add(&sop->so_idhash, &lock_ownerid_hashtbl[idhashval]);
3909 list_add(&sop->so_strhash, &lock_ownerstr_hashtbl[strhashval]);
NeilBrownea1da632005-06-23 22:04:17 -07003910 list_add(&sop->so_perstateid, &open_stp->st_lockowners);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003911 sop->so_is_open_owner = 0;
3912 sop->so_id = current_ownerid++;
3913 sop->so_client = clp;
Neil Brownb59e3c02005-09-13 01:25:38 -07003914 /* It is the openowner seqid that will be incremented in encode in the
3915 * case of new lockowners; so increment the lock seqid manually: */
3916 sop->so_seqid = lock->lk_new_lock_seqid + 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003917 sop->so_confirmed = 1;
3918 rp = &sop->so_replay;
Al Virode1ae282006-01-18 17:43:47 -08003919 rp->rp_status = nfserr_serverfault;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003920 rp->rp_buflen = 0;
3921 rp->rp_buf = rp->rp_ibuf;
3922 return sop;
3923}
3924
NeilBrownfd39ca92005-06-23 22:04:03 -07003925static struct nfs4_stateid *
Linus Torvalds1da177e2005-04-16 15:20:36 -07003926alloc_init_lock_stateid(struct nfs4_stateowner *sop, struct nfs4_file *fp, struct nfs4_stateid *open_stp)
3927{
3928 struct nfs4_stateid *stp;
3929 unsigned int hashval = stateid_hashval(sop->so_id, fp->fi_id);
3930
NeilBrown5ac049a2005-06-23 22:03:03 -07003931 stp = nfs4_alloc_stateid();
3932 if (stp == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003933 goto out;
3934 INIT_LIST_HEAD(&stp->st_hash);
3935 INIT_LIST_HEAD(&stp->st_perfile);
NeilBrownea1da632005-06-23 22:04:17 -07003936 INIT_LIST_HEAD(&stp->st_perstateowner);
3937 INIT_LIST_HEAD(&stp->st_lockowners); /* not used */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003938 list_add(&stp->st_hash, &lockstateid_hashtbl[hashval]);
NeilBrown8beefa22005-06-23 22:03:08 -07003939 list_add(&stp->st_perfile, &fp->fi_stateids);
NeilBrownea1da632005-06-23 22:04:17 -07003940 list_add(&stp->st_perstateowner, &sop->so_stateids);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003941 stp->st_stateowner = sop;
NeilBrown13cd2182005-06-23 22:03:10 -07003942 get_nfs4_file(fp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003943 stp->st_file = fp;
J. Bruce Fieldse4e83ea2010-04-22 16:21:39 -04003944 stp->st_stateid.si_boot = boot_time;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003945 stp->st_stateid.si_stateownerid = sop->so_id;
3946 stp->st_stateid.si_fileid = fp->fi_id;
3947 stp->st_stateid.si_generation = 0;
J. Bruce Fields0997b172011-03-02 18:01:35 -05003948 stp->st_access_bmap = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003949 stp->st_deny_bmap = open_stp->st_deny_bmap;
NeilBrown4c4cd222005-07-07 17:59:27 -07003950 stp->st_openstp = open_stp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003951
3952out:
3953 return stp;
3954}
3955
NeilBrownfd39ca92005-06-23 22:04:03 -07003956static int
Linus Torvalds1da177e2005-04-16 15:20:36 -07003957check_lock_length(u64 offset, u64 length)
3958{
Benny Halevy87df4de2008-12-15 19:42:03 +02003959 return ((length == 0) || ((length != NFS4_MAX_UINT64) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07003960 LOFF_OVERFLOW(offset, length)));
3961}
3962
J. Bruce Fields0997b172011-03-02 18:01:35 -05003963static void get_lock_access(struct nfs4_stateid *lock_stp, u32 access)
3964{
3965 struct nfs4_file *fp = lock_stp->st_file;
3966 int oflag = nfs4_access_to_omode(access);
3967
3968 if (test_bit(access, &lock_stp->st_access_bmap))
3969 return;
3970 nfs4_file_get_access(fp, oflag);
3971 __set_bit(access, &lock_stp->st_access_bmap);
3972}
3973
Linus Torvalds1da177e2005-04-16 15:20:36 -07003974/*
3975 * LOCK operation
3976 */
Al Virob37ad282006-10-19 23:28:59 -07003977__be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003978nfsd4_lock(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
J.Bruce Fieldsa4f1706a92006-12-13 00:35:28 -08003979 struct nfsd4_lock *lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003980{
NeilBrown3e9e3db2005-06-23 22:04:20 -07003981 struct nfs4_stateowner *open_sop = NULL;
Neil Brownb59e3c02005-09-13 01:25:38 -07003982 struct nfs4_stateowner *lock_sop = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003983 struct nfs4_stateid *lock_stp;
J. Bruce Fields7d947842010-08-20 18:09:31 -04003984 struct nfs4_file *fp;
3985 struct file *filp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003986 struct file_lock file_lock;
Andy Adamson8dc7c312006-03-20 13:44:26 -05003987 struct file_lock conflock;
Al Virob37ad282006-10-19 23:28:59 -07003988 __be32 status = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003989 unsigned int strhashval;
Al Virob8dd7b92006-10-19 23:29:01 -07003990 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003991
3992 dprintk("NFSD: nfsd4_lock: start=%Ld length=%Ld\n",
3993 (long long) lock->lk_offset,
3994 (long long) lock->lk_length);
3995
Linus Torvalds1da177e2005-04-16 15:20:36 -07003996 if (check_lock_length(lock->lk_offset, lock->lk_length))
3997 return nfserr_inval;
3998
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003999 if ((status = fh_verify(rqstp, &cstate->current_fh,
Miklos Szeredi8837abc2008-06-16 13:20:29 +02004000 S_IFREG, NFSD_MAY_LOCK))) {
Andy Adamsona6f6ef22006-01-18 17:43:17 -08004001 dprintk("NFSD: nfsd4_lock: permission denied!\n");
4002 return status;
4003 }
4004
Linus Torvalds1da177e2005-04-16 15:20:36 -07004005 nfs4_lock_state();
4006
4007 if (lock->lk_is_new) {
NeilBrown893f8772005-07-07 17:59:17 -07004008 /*
4009 * Client indicates that this is a new lockowner.
4010 * Use open owner and open stateid to create lock owner and
4011 * lock stateid.
4012 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07004013 struct nfs4_stateid *open_stp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004014
4015 status = nfserr_stale_clientid;
Andy Adamson60adfc52009-04-03 08:28:50 +03004016 if (!nfsd4_has_session(cstate) &&
4017 STALE_CLIENTID(&lock->lk_new_clientid))
Linus Torvalds1da177e2005-04-16 15:20:36 -07004018 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004019
Linus Torvalds1da177e2005-04-16 15:20:36 -07004020 /* validate and update open stateid and open seqid */
Benny Halevydd453df2009-04-03 08:28:41 +03004021 status = nfs4_preprocess_seqid_op(cstate,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004022 lock->lk_new_open_seqid,
4023 &lock->lk_new_open_stateid,
J. Bruce Fieldsf3362732008-01-26 14:58:45 -05004024 OPEN_STATE,
J. Bruce Fields3a655882006-01-18 17:43:19 -08004025 &lock->lk_replay_owner, &open_stp,
Neil Brownb59e3c02005-09-13 01:25:38 -07004026 lock);
NeilBrown37515172005-07-07 17:59:16 -07004027 if (status)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004028 goto out;
J. Bruce Fields3a655882006-01-18 17:43:19 -08004029 open_sop = lock->lk_replay_owner;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004030 /* create lockowner and lock stateid */
4031 fp = open_stp->st_file;
4032 strhashval = lock_ownerstr_hashval(fp->fi_inode,
4033 open_sop->so_client->cl_clientid.cl_id,
4034 &lock->v.new.owner);
NeilBrown3e9e3db2005-06-23 22:04:20 -07004035 /* XXX: Do we need to check for duplicate stateowners on
4036 * the same file, or should they just be allowed (and
4037 * create new stateids)? */
Linus Torvalds1da177e2005-04-16 15:20:36 -07004038 status = nfserr_resource;
Neil Brownb59e3c02005-09-13 01:25:38 -07004039 lock_sop = alloc_init_lock_stateowner(strhashval,
4040 open_sop->so_client, open_stp, lock);
4041 if (lock_sop == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004042 goto out;
Neil Brownb59e3c02005-09-13 01:25:38 -07004043 lock_stp = alloc_init_lock_stateid(lock_sop, fp, open_stp);
J. Bruce Fields8a280512006-01-18 17:43:18 -08004044 if (lock_stp == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004045 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004046 } else {
4047 /* lock (lock owner + lock stateid) already exists */
Benny Halevydd453df2009-04-03 08:28:41 +03004048 status = nfs4_preprocess_seqid_op(cstate,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004049 lock->lk_old_lock_seqid,
4050 &lock->lk_old_lock_stateid,
J. Bruce Fieldsf3362732008-01-26 14:58:45 -05004051 LOCK_STATE,
J. Bruce Fields3a655882006-01-18 17:43:19 -08004052 &lock->lk_replay_owner, &lock_stp, lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004053 if (status)
4054 goto out;
J. Bruce Fields3a655882006-01-18 17:43:19 -08004055 lock_sop = lock->lk_replay_owner;
J. Bruce Fields7d947842010-08-20 18:09:31 -04004056 fp = lock_stp->st_file;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004057 }
J. Bruce Fields3a655882006-01-18 17:43:19 -08004058 /* lock->lk_replay_owner and lock_stp have been created or found */
Linus Torvalds1da177e2005-04-16 15:20:36 -07004059
NeilBrown0dd395d2005-07-07 17:59:15 -07004060 status = nfserr_grace;
J. Bruce Fieldsaf558e32007-09-06 12:34:25 -04004061 if (locks_in_grace() && !lock->lk_reclaim)
NeilBrown0dd395d2005-07-07 17:59:15 -07004062 goto out;
4063 status = nfserr_no_grace;
J. Bruce Fieldsaf558e32007-09-06 12:34:25 -04004064 if (!locks_in_grace() && lock->lk_reclaim)
NeilBrown0dd395d2005-07-07 17:59:15 -07004065 goto out;
4066
Linus Torvalds1da177e2005-04-16 15:20:36 -07004067 locks_init_lock(&file_lock);
4068 switch (lock->lk_type) {
4069 case NFS4_READ_LT:
4070 case NFS4_READW_LT:
J. Bruce Fields0997b172011-03-02 18:01:35 -05004071 filp = find_readable_file(lock_stp->st_file);
4072 if (filp)
4073 get_lock_access(lock_stp, NFS4_SHARE_ACCESS_READ);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004074 file_lock.fl_type = F_RDLCK;
J. Bruce Fields529d7b22011-03-02 23:48:33 -05004075 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004076 case NFS4_WRITE_LT:
4077 case NFS4_WRITEW_LT:
J. Bruce Fields0997b172011-03-02 18:01:35 -05004078 filp = find_writeable_file(lock_stp->st_file);
4079 if (filp)
4080 get_lock_access(lock_stp, NFS4_SHARE_ACCESS_WRITE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004081 file_lock.fl_type = F_WRLCK;
J. Bruce Fields529d7b22011-03-02 23:48:33 -05004082 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004083 default:
4084 status = nfserr_inval;
4085 goto out;
4086 }
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04004087 if (!filp) {
4088 status = nfserr_openmode;
4089 goto out;
4090 }
Neil Brownb59e3c02005-09-13 01:25:38 -07004091 file_lock.fl_owner = (fl_owner_t)lock_sop;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004092 file_lock.fl_pid = current->tgid;
4093 file_lock.fl_file = filp;
4094 file_lock.fl_flags = FL_POSIX;
NeilBrownd5b90262006-04-10 22:55:22 -07004095 file_lock.fl_lmops = &nfsd_posix_mng_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004096
4097 file_lock.fl_start = lock->lk_offset;
Benny Halevy87df4de2008-12-15 19:42:03 +02004098 file_lock.fl_end = last_byte_offset(lock->lk_offset, lock->lk_length);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004099 nfs4_transform_lock_offset(&file_lock);
4100
4101 /*
4102 * Try to lock the file in the VFS.
4103 * Note: locks.c uses the BKL to protect the inode's lock list.
4104 */
4105
J. Bruce Fields529d7b22011-03-02 23:48:33 -05004106 err = vfs_lock_file(filp, F_SETLK, &file_lock, &conflock);
Al Virob8dd7b92006-10-19 23:29:01 -07004107 switch (-err) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004108 case 0: /* success! */
4109 update_stateid(&lock_stp->st_stateid);
4110 memcpy(&lock->lk_resp_stateid, &lock_stp->st_stateid,
4111 sizeof(stateid_t));
Al Virob8dd7b92006-10-19 23:29:01 -07004112 status = 0;
Andy Adamsoneb76b3f2006-03-26 01:37:26 -08004113 break;
4114 case (EAGAIN): /* conflock holds conflicting lock */
4115 status = nfserr_denied;
4116 dprintk("NFSD: nfsd4_lock: conflicting lock found!\n");
4117 nfs4_set_lock_denied(&conflock, &lock->lk_denied);
4118 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004119 case (EDEADLK):
4120 status = nfserr_deadlock;
Andy Adamsoneb76b3f2006-03-26 01:37:26 -08004121 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004122 default:
Marc Eshelfd85b812006-11-28 16:26:41 -05004123 dprintk("NFSD: nfsd4_lock: vfs_lock_file() failed! status %d\n",err);
Andy Adamsoneb76b3f2006-03-26 01:37:26 -08004124 status = nfserr_resource;
4125 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004126 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004127out:
J. Bruce Fields8a280512006-01-18 17:43:18 -08004128 if (status && lock->lk_is_new && lock_sop)
J. Bruce Fieldsf044ff82009-01-11 15:24:04 -05004129 release_lockowner(lock_sop);
J. Bruce Fields3a655882006-01-18 17:43:19 -08004130 if (lock->lk_replay_owner) {
4131 nfs4_get_stateowner(lock->lk_replay_owner);
J.Bruce Fieldsa4f1706a92006-12-13 00:35:28 -08004132 cstate->replay_owner = lock->lk_replay_owner;
Neil Brownf2327d92005-09-13 01:25:37 -07004133 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004134 nfs4_unlock_state();
4135 return status;
4136}
4137
4138/*
J. Bruce Fields55ef1272008-12-20 11:58:38 -08004139 * The NFSv4 spec allows a client to do a LOCKT without holding an OPEN,
4140 * so we do a temporary open here just to get an open file to pass to
4141 * vfs_test_lock. (Arguably perhaps test_lock should be done with an
4142 * inode operation.)
4143 */
4144static int nfsd_test_lock(struct svc_rqst *rqstp, struct svc_fh *fhp, struct file_lock *lock)
4145{
4146 struct file *file;
4147 int err;
4148
4149 err = nfsd_open(rqstp, fhp, S_IFREG, NFSD_MAY_READ, &file);
4150 if (err)
4151 return err;
4152 err = vfs_test_lock(file, lock);
4153 nfsd_close(file);
4154 return err;
4155}
4156
4157/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07004158 * LOCKT operation
4159 */
Al Virob37ad282006-10-19 23:28:59 -07004160__be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -08004161nfsd4_lockt(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
4162 struct nfsd4_lockt *lockt)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004163{
4164 struct inode *inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004165 struct file_lock file_lock;
Marc Eshelfd85b812006-11-28 16:26:41 -05004166 int error;
Al Virob37ad282006-10-19 23:28:59 -07004167 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004168
J. Bruce Fieldsaf558e32007-09-06 12:34:25 -04004169 if (locks_in_grace())
Linus Torvalds1da177e2005-04-16 15:20:36 -07004170 return nfserr_grace;
4171
4172 if (check_lock_length(lockt->lt_offset, lockt->lt_length))
4173 return nfserr_inval;
4174
4175 lockt->lt_stateowner = NULL;
4176 nfs4_lock_state();
4177
4178 status = nfserr_stale_clientid;
Andy Adamson60adfc52009-04-03 08:28:50 +03004179 if (!nfsd4_has_session(cstate) && STALE_CLIENTID(&lockt->lt_clientid))
Linus Torvalds1da177e2005-04-16 15:20:36 -07004180 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004181
J.Bruce Fieldsca364312006-12-13 00:35:27 -08004182 if ((status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0))) {
Neil Brown849823c2005-09-13 01:25:36 -07004183 dprintk("NFSD: nfsd4_lockt: fh_verify() failed!\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07004184 if (status == nfserr_symlink)
4185 status = nfserr_inval;
4186 goto out;
4187 }
4188
J.Bruce Fieldsca364312006-12-13 00:35:27 -08004189 inode = cstate->current_fh.fh_dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004190 locks_init_lock(&file_lock);
4191 switch (lockt->lt_type) {
4192 case NFS4_READ_LT:
4193 case NFS4_READW_LT:
4194 file_lock.fl_type = F_RDLCK;
4195 break;
4196 case NFS4_WRITE_LT:
4197 case NFS4_WRITEW_LT:
4198 file_lock.fl_type = F_WRLCK;
4199 break;
4200 default:
J. Bruce Fields2fdada02007-07-27 16:10:37 -04004201 dprintk("NFSD: nfs4_lockt: bad lock type!\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07004202 status = nfserr_inval;
4203 goto out;
4204 }
4205
4206 lockt->lt_stateowner = find_lockstateowner_str(inode,
4207 &lockt->lt_clientid, &lockt->lt_owner);
4208 if (lockt->lt_stateowner)
4209 file_lock.fl_owner = (fl_owner_t)lockt->lt_stateowner;
4210 file_lock.fl_pid = current->tgid;
4211 file_lock.fl_flags = FL_POSIX;
4212
4213 file_lock.fl_start = lockt->lt_offset;
Benny Halevy87df4de2008-12-15 19:42:03 +02004214 file_lock.fl_end = last_byte_offset(lockt->lt_offset, lockt->lt_length);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004215
4216 nfs4_transform_lock_offset(&file_lock);
4217
Linus Torvalds1da177e2005-04-16 15:20:36 -07004218 status = nfs_ok;
J. Bruce Fields55ef1272008-12-20 11:58:38 -08004219 error = nfsd_test_lock(rqstp, &cstate->current_fh, &file_lock);
Marc Eshelfd85b812006-11-28 16:26:41 -05004220 if (error) {
4221 status = nfserrno(error);
4222 goto out;
4223 }
Marc Eshel9d6a8c52007-02-21 00:55:18 -05004224 if (file_lock.fl_type != F_UNLCK) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004225 status = nfserr_denied;
Marc Eshel9d6a8c52007-02-21 00:55:18 -05004226 nfs4_set_lock_denied(&file_lock, &lockt->lt_denied);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004227 }
4228out:
4229 nfs4_unlock_state();
4230 return status;
4231}
4232
Al Virob37ad282006-10-19 23:28:59 -07004233__be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -08004234nfsd4_locku(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
J.Bruce Fieldsa4f1706a92006-12-13 00:35:28 -08004235 struct nfsd4_locku *locku)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004236{
4237 struct nfs4_stateid *stp;
4238 struct file *filp = NULL;
4239 struct file_lock file_lock;
Al Virob37ad282006-10-19 23:28:59 -07004240 __be32 status;
Al Virob8dd7b92006-10-19 23:29:01 -07004241 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004242
4243 dprintk("NFSD: nfsd4_locku: start=%Ld length=%Ld\n",
4244 (long long) locku->lu_offset,
4245 (long long) locku->lu_length);
4246
4247 if (check_lock_length(locku->lu_offset, locku->lu_length))
4248 return nfserr_inval;
4249
4250 nfs4_lock_state();
4251
Benny Halevydd453df2009-04-03 08:28:41 +03004252 if ((status = nfs4_preprocess_seqid_op(cstate,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004253 locku->lu_seqid,
4254 &locku->lu_stateid,
J. Bruce Fieldsf3362732008-01-26 14:58:45 -05004255 LOCK_STATE,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004256 &locku->lu_stateowner, &stp, NULL)))
4257 goto out;
4258
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04004259 filp = find_any_file(stp->st_file);
4260 if (!filp) {
4261 status = nfserr_lock_range;
4262 goto out;
4263 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004264 BUG_ON(!filp);
4265 locks_init_lock(&file_lock);
4266 file_lock.fl_type = F_UNLCK;
4267 file_lock.fl_owner = (fl_owner_t) locku->lu_stateowner;
4268 file_lock.fl_pid = current->tgid;
4269 file_lock.fl_file = filp;
4270 file_lock.fl_flags = FL_POSIX;
NeilBrownd5b90262006-04-10 22:55:22 -07004271 file_lock.fl_lmops = &nfsd_posix_mng_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004272 file_lock.fl_start = locku->lu_offset;
4273
Benny Halevy87df4de2008-12-15 19:42:03 +02004274 file_lock.fl_end = last_byte_offset(locku->lu_offset, locku->lu_length);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004275 nfs4_transform_lock_offset(&file_lock);
4276
4277 /*
4278 * Try to unlock the file in the VFS.
4279 */
Marc Eshelfd85b812006-11-28 16:26:41 -05004280 err = vfs_lock_file(filp, F_SETLK, &file_lock, NULL);
Al Virob8dd7b92006-10-19 23:29:01 -07004281 if (err) {
Marc Eshelfd85b812006-11-28 16:26:41 -05004282 dprintk("NFSD: nfs4_locku: vfs_lock_file failed!\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07004283 goto out_nfserr;
4284 }
4285 /*
4286 * OK, unlock succeeded; the only thing left to do is update the stateid.
4287 */
4288 update_stateid(&stp->st_stateid);
4289 memcpy(&locku->lu_stateid, &stp->st_stateid, sizeof(stateid_t));
4290
4291out:
Neil Brownf2327d92005-09-13 01:25:37 -07004292 if (locku->lu_stateowner) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004293 nfs4_get_stateowner(locku->lu_stateowner);
J.Bruce Fieldsa4f1706a92006-12-13 00:35:28 -08004294 cstate->replay_owner = locku->lu_stateowner;
Neil Brownf2327d92005-09-13 01:25:37 -07004295 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004296 nfs4_unlock_state();
4297 return status;
4298
4299out_nfserr:
Al Virob8dd7b92006-10-19 23:29:01 -07004300 status = nfserrno(err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004301 goto out;
4302}
4303
4304/*
4305 * returns
4306 * 1: locks held by lockowner
4307 * 0: no locks held by lockowner
4308 */
4309static int
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04004310check_for_locks(struct nfs4_file *filp, struct nfs4_stateowner *lowner)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004311{
4312 struct file_lock **flpp;
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04004313 struct inode *inode = filp->fi_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004314 int status = 0;
4315
Arnd Bergmannb89f4322010-09-18 15:09:31 +02004316 lock_flocks();
Linus Torvalds1da177e2005-04-16 15:20:36 -07004317 for (flpp = &inode->i_flock; *flpp != NULL; flpp = &(*flpp)->fl_next) {
J. Bruce Fields796dadf2006-01-18 17:43:22 -08004318 if ((*flpp)->fl_owner == (fl_owner_t)lowner) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004319 status = 1;
4320 goto out;
J. Bruce Fields796dadf2006-01-18 17:43:22 -08004321 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004322 }
4323out:
Arnd Bergmannb89f4322010-09-18 15:09:31 +02004324 unlock_flocks();
Linus Torvalds1da177e2005-04-16 15:20:36 -07004325 return status;
4326}
4327
Al Virob37ad282006-10-19 23:28:59 -07004328__be32
J.Bruce Fieldsb5914802006-12-13 00:35:38 -08004329nfsd4_release_lockowner(struct svc_rqst *rqstp,
4330 struct nfsd4_compound_state *cstate,
4331 struct nfsd4_release_lockowner *rlockowner)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004332{
4333 clientid_t *clid = &rlockowner->rl_clientid;
NeilBrown3e9e3db2005-06-23 22:04:20 -07004334 struct nfs4_stateowner *sop;
4335 struct nfs4_stateid *stp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004336 struct xdr_netobj *owner = &rlockowner->rl_owner;
NeilBrown3e9e3db2005-06-23 22:04:20 -07004337 struct list_head matches;
4338 int i;
Al Virob37ad282006-10-19 23:28:59 -07004339 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004340
4341 dprintk("nfsd4_release_lockowner clientid: (%08x/%08x):\n",
4342 clid->cl_boot, clid->cl_id);
4343
4344 /* XXX check for lease expiration */
4345
4346 status = nfserr_stale_clientid;
Neil Brown849823c2005-09-13 01:25:36 -07004347 if (STALE_CLIENTID(clid))
Linus Torvalds1da177e2005-04-16 15:20:36 -07004348 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004349
4350 nfs4_lock_state();
4351
NeilBrown3e9e3db2005-06-23 22:04:20 -07004352 status = nfserr_locks_held;
4353 /* XXX: we're doing a linear search through all the lockowners.
4354 * Yipes! For now we'll just hope clients aren't really using
4355 * release_lockowner much, but eventually we have to fix these
4356 * data structures. */
4357 INIT_LIST_HEAD(&matches);
4358 for (i = 0; i < LOCK_HASH_SIZE; i++) {
4359 list_for_each_entry(sop, &lock_ownerid_hashtbl[i], so_idhash) {
J. Bruce Fields599e0a22007-07-26 17:04:54 -04004360 if (!same_owner_str(sop, owner, clid))
NeilBrown3e9e3db2005-06-23 22:04:20 -07004361 continue;
4362 list_for_each_entry(stp, &sop->so_stateids,
4363 st_perstateowner) {
J. Bruce Fieldsf9d75622010-07-08 11:02:09 -04004364 if (check_for_locks(stp->st_file, sop))
NeilBrown3e9e3db2005-06-23 22:04:20 -07004365 goto out;
4366 /* Note: so_perclient unused for lockowners,
4367 * so it's OK to fool with here. */
4368 list_add(&sop->so_perclient, &matches);
4369 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004370 }
NeilBrown3e9e3db2005-06-23 22:04:20 -07004371 }
4372 /* Clients probably won't expect us to return with some (but not all)
4373 * of the lockowner state released; so don't release any until all
4374 * have been checked. */
4375 status = nfs_ok;
NeilBrown0fa822e2005-07-07 17:59:14 -07004376 while (!list_empty(&matches)) {
4377 sop = list_entry(matches.next, struct nfs4_stateowner,
4378 so_perclient);
4379 /* unhash_stateowner deletes so_perclient only
4380 * for openowners. */
4381 list_del(&sop->so_perclient);
J. Bruce Fieldsf044ff82009-01-11 15:24:04 -05004382 release_lockowner(sop);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004383 }
4384out:
4385 nfs4_unlock_state();
4386 return status;
4387}
4388
4389static inline struct nfs4_client_reclaim *
NeilBrowna55370a2005-06-23 22:03:52 -07004390alloc_reclaim(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004391{
NeilBrowna55370a2005-06-23 22:03:52 -07004392 return kmalloc(sizeof(struct nfs4_client_reclaim), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004393}
4394
NeilBrownc7b9a452005-06-23 22:04:30 -07004395int
Andy Adamsona1bcecd2009-04-03 08:28:05 +03004396nfs4_has_reclaimed_state(const char *name, bool use_exchange_id)
NeilBrownc7b9a452005-06-23 22:04:30 -07004397{
4398 unsigned int strhashval = clientstr_hashval(name);
4399 struct nfs4_client *clp;
4400
J. Bruce Fieldse203d502010-11-24 17:30:54 -05004401 clp = find_confirmed_client_by_str(name, strhashval);
NeilBrownc7b9a452005-06-23 22:04:30 -07004402 return clp ? 1 : 0;
4403}
4404
Linus Torvalds1da177e2005-04-16 15:20:36 -07004405/*
4406 * failure => all reset bets are off, nfserr_no_grace...
4407 */
NeilBrown190e4fb2005-06-23 22:04:25 -07004408int
4409nfs4_client_to_reclaim(const char *name)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004410{
4411 unsigned int strhashval;
4412 struct nfs4_client_reclaim *crp = NULL;
4413
NeilBrowna55370a2005-06-23 22:03:52 -07004414 dprintk("NFSD nfs4_client_to_reclaim NAME: %.*s\n", HEXDIR_LEN, name);
4415 crp = alloc_reclaim();
Linus Torvalds1da177e2005-04-16 15:20:36 -07004416 if (!crp)
4417 return 0;
NeilBrowna55370a2005-06-23 22:03:52 -07004418 strhashval = clientstr_hashval(name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004419 INIT_LIST_HEAD(&crp->cr_strhash);
4420 list_add(&crp->cr_strhash, &reclaim_str_hashtbl[strhashval]);
NeilBrowna55370a2005-06-23 22:03:52 -07004421 memcpy(crp->cr_recdir, name, HEXDIR_LEN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004422 reclaim_str_hashtbl_size++;
4423 return 1;
4424}
4425
4426static void
4427nfs4_release_reclaim(void)
4428{
4429 struct nfs4_client_reclaim *crp = NULL;
4430 int i;
4431
Linus Torvalds1da177e2005-04-16 15:20:36 -07004432 for (i = 0; i < CLIENT_HASH_SIZE; i++) {
4433 while (!list_empty(&reclaim_str_hashtbl[i])) {
4434 crp = list_entry(reclaim_str_hashtbl[i].next,
4435 struct nfs4_client_reclaim, cr_strhash);
4436 list_del(&crp->cr_strhash);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004437 kfree(crp);
4438 reclaim_str_hashtbl_size--;
4439 }
4440 }
4441 BUG_ON(reclaim_str_hashtbl_size);
4442}
4443
4444/*
4445 * called from OPEN, CLAIM_PREVIOUS with a new clientid. */
NeilBrownfd39ca92005-06-23 22:04:03 -07004446static struct nfs4_client_reclaim *
Linus Torvalds1da177e2005-04-16 15:20:36 -07004447nfs4_find_reclaim_client(clientid_t *clid)
4448{
4449 unsigned int strhashval;
4450 struct nfs4_client *clp;
4451 struct nfs4_client_reclaim *crp = NULL;
4452
4453
4454 /* find clientid in conf_id_hashtbl */
4455 clp = find_confirmed_client(clid);
4456 if (clp == NULL)
4457 return NULL;
4458
NeilBrowna55370a2005-06-23 22:03:52 -07004459 dprintk("NFSD: nfs4_find_reclaim_client for %.*s with recdir %s\n",
4460 clp->cl_name.len, clp->cl_name.data,
4461 clp->cl_recdir);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004462
4463 /* find clp->cl_name in reclaim_str_hashtbl */
NeilBrowna55370a2005-06-23 22:03:52 -07004464 strhashval = clientstr_hashval(clp->cl_recdir);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004465 list_for_each_entry(crp, &reclaim_str_hashtbl[strhashval], cr_strhash) {
NeilBrowna55370a2005-06-23 22:03:52 -07004466 if (same_name(crp->cr_recdir, clp->cl_recdir)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004467 return crp;
4468 }
4469 }
4470 return NULL;
4471}
4472
4473/*
4474* Called from OPEN. Look for clientid in reclaim list.
4475*/
Al Virob37ad282006-10-19 23:28:59 -07004476__be32
Linus Torvalds1da177e2005-04-16 15:20:36 -07004477nfs4_check_open_reclaim(clientid_t *clid)
4478{
NeilBrowndfc83562005-06-23 22:03:16 -07004479 return nfs4_find_reclaim_client(clid) ? nfs_ok : nfserr_reclaim_bad;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004480}
4481
NeilBrownac4d8ff22005-06-23 22:03:30 -07004482/* initialization to perform at module load time: */
Linus Torvalds1da177e2005-04-16 15:20:36 -07004483
J. Bruce Fieldse8ff2a82007-08-01 15:30:59 -04004484int
NeilBrownac4d8ff22005-06-23 22:03:30 -07004485nfs4_state_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004486{
J. Bruce Fieldse8ff2a82007-08-01 15:30:59 -04004487 int i, status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004488
J. Bruce Fieldse8ff2a82007-08-01 15:30:59 -04004489 status = nfsd4_init_slabs();
4490 if (status)
4491 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004492 for (i = 0; i < CLIENT_HASH_SIZE; i++) {
4493 INIT_LIST_HEAD(&conf_id_hashtbl[i]);
4494 INIT_LIST_HEAD(&conf_str_hashtbl[i]);
4495 INIT_LIST_HEAD(&unconf_str_hashtbl[i]);
4496 INIT_LIST_HEAD(&unconf_id_hashtbl[i]);
Wang Chen02cb2852009-04-24 15:41:57 +08004497 INIT_LIST_HEAD(&reclaim_str_hashtbl[i]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004498 }
Marc Eshel5282fd72009-04-03 08:27:52 +03004499 for (i = 0; i < SESSION_HASH_SIZE; i++)
4500 INIT_LIST_HEAD(&sessionid_hashtbl[i]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004501 for (i = 0; i < FILE_HASH_SIZE; i++) {
4502 INIT_LIST_HEAD(&file_hashtbl[i]);
4503 }
4504 for (i = 0; i < OWNER_HASH_SIZE; i++) {
4505 INIT_LIST_HEAD(&ownerstr_hashtbl[i]);
4506 INIT_LIST_HEAD(&ownerid_hashtbl[i]);
4507 }
4508 for (i = 0; i < STATEID_HASH_SIZE; i++) {
4509 INIT_LIST_HEAD(&stateid_hashtbl[i]);
4510 INIT_LIST_HEAD(&lockstateid_hashtbl[i]);
4511 }
4512 for (i = 0; i < LOCK_HASH_SIZE; i++) {
4513 INIT_LIST_HEAD(&lock_ownerid_hashtbl[i]);
4514 INIT_LIST_HEAD(&lock_ownerstr_hashtbl[i]);
4515 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004516 memset(&onestateid, ~0, sizeof(stateid_t));
Linus Torvalds1da177e2005-04-16 15:20:36 -07004517 INIT_LIST_HEAD(&close_lru);
4518 INIT_LIST_HEAD(&client_lru);
4519 INIT_LIST_HEAD(&del_recall_lru);
NeilBrownac4d8ff22005-06-23 22:03:30 -07004520 reclaim_str_hashtbl_size = 0;
J. Bruce Fieldse8ff2a82007-08-01 15:30:59 -04004521 return 0;
NeilBrownac4d8ff22005-06-23 22:03:30 -07004522}
4523
NeilBrown190e4fb2005-06-23 22:04:25 -07004524static void
4525nfsd4_load_reboot_recovery_data(void)
4526{
4527 int status;
4528
NeilBrown0964a3d2005-06-23 22:04:32 -07004529 nfs4_lock_state();
4530 nfsd4_init_recdir(user_recovery_dirname);
NeilBrown190e4fb2005-06-23 22:04:25 -07004531 status = nfsd4_recdir_load();
NeilBrown0964a3d2005-06-23 22:04:32 -07004532 nfs4_unlock_state();
NeilBrown190e4fb2005-06-23 22:04:25 -07004533 if (status)
4534 printk("NFSD: Failure reading reboot recovery data\n");
4535}
4536
Meelap Shahc2f1a552007-07-17 04:04:39 -07004537/*
4538 * Since the lifetime of a delegation isn't limited to that of an open, a
4539 * client may quite reasonably hang on to a delegation as long as it has
4540 * the inode cached. This becomes an obvious problem the first time a
4541 * client's inode cache approaches the size of the server's total memory.
4542 *
4543 * For now we avoid this problem by imposing a hard limit on the number
4544 * of delegations, which varies according to the server's memory size.
4545 */
4546static void
4547set_max_delegations(void)
4548{
4549 /*
4550 * Allow at most 4 delegations per megabyte of RAM. Quick
4551 * estimates suggest that in the worst case (where every delegation
4552 * is for a different inode), a delegation could take about 1.5K,
4553 * giving a worst case usage of about 6% of memory.
4554 */
4555 max_delegations = nr_free_buffer_pages() >> (20 - 2 - PAGE_SHIFT);
4556}
4557
NeilBrownac4d8ff22005-06-23 22:03:30 -07004558/* initialization to perform when the nfsd service is started: */
4559
J. Bruce Fields29ab23c2009-09-15 15:56:50 -04004560static int
NeilBrownac4d8ff22005-06-23 22:03:30 -07004561__nfs4_state_start(void)
4562{
J. Bruce Fieldsb5a1a812010-03-03 14:52:55 -05004563 int ret;
4564
Linus Torvalds1da177e2005-04-16 15:20:36 -07004565 boot_time = get_seconds();
J. Bruce Fieldsaf558e32007-09-06 12:34:25 -04004566 locks_start_grace(&nfsd4_manager);
Marc Eshel9a8db972007-07-17 04:04:35 -07004567 printk(KERN_INFO "NFSD: starting %ld-second grace period\n",
J. Bruce Fieldse46b4982010-03-01 19:21:21 -05004568 nfsd4_grace);
J. Bruce Fieldsb5a1a812010-03-03 14:52:55 -05004569 ret = set_callback_cred();
4570 if (ret)
4571 return -ENOMEM;
NeilBrown58da2822005-06-23 22:03:19 -07004572 laundry_wq = create_singlethread_workqueue("nfsd4");
J. Bruce Fields29ab23c2009-09-15 15:56:50 -04004573 if (laundry_wq == NULL)
4574 return -ENOMEM;
J. Bruce Fieldsb5a1a812010-03-03 14:52:55 -05004575 ret = nfsd4_create_callback_queue();
4576 if (ret)
4577 goto out_free_laundry;
J. Bruce Fieldse46b4982010-03-01 19:21:21 -05004578 queue_delayed_work(laundry_wq, &laundromat_work, nfsd4_grace * HZ);
Meelap Shahc2f1a552007-07-17 04:04:39 -07004579 set_max_delegations();
J. Bruce Fieldsb5a1a812010-03-03 14:52:55 -05004580 return 0;
4581out_free_laundry:
4582 destroy_workqueue(laundry_wq);
4583 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004584}
4585
J. Bruce Fields29ab23c2009-09-15 15:56:50 -04004586int
NeilBrown76a35502005-06-23 22:03:26 -07004587nfs4_state_start(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004588{
NeilBrown190e4fb2005-06-23 22:04:25 -07004589 nfsd4_load_reboot_recovery_data();
Jeff Layton4ad9a342010-07-19 16:50:04 -04004590 return __nfs4_state_start();
Linus Torvalds1da177e2005-04-16 15:20:36 -07004591}
4592
Linus Torvalds1da177e2005-04-16 15:20:36 -07004593static void
4594__nfs4_state_shutdown(void)
4595{
4596 int i;
4597 struct nfs4_client *clp = NULL;
4598 struct nfs4_delegation *dp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004599 struct list_head *pos, *next, reaplist;
4600
Linus Torvalds1da177e2005-04-16 15:20:36 -07004601 for (i = 0; i < CLIENT_HASH_SIZE; i++) {
4602 while (!list_empty(&conf_id_hashtbl[i])) {
4603 clp = list_entry(conf_id_hashtbl[i].next, struct nfs4_client, cl_idhash);
4604 expire_client(clp);
4605 }
4606 while (!list_empty(&unconf_str_hashtbl[i])) {
4607 clp = list_entry(unconf_str_hashtbl[i].next, struct nfs4_client, cl_strhash);
4608 expire_client(clp);
4609 }
4610 }
4611 INIT_LIST_HEAD(&reaplist);
4612 spin_lock(&recall_lock);
4613 list_for_each_safe(pos, next, &del_recall_lru) {
4614 dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
4615 list_move(&dp->dl_recall_lru, &reaplist);
4616 }
4617 spin_unlock(&recall_lock);
4618 list_for_each_safe(pos, next, &reaplist) {
4619 dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
4620 list_del_init(&dp->dl_recall_lru);
4621 unhash_delegation(dp);
4622 }
4623
NeilBrown190e4fb2005-06-23 22:04:25 -07004624 nfsd4_shutdown_recdir();
Linus Torvalds1da177e2005-04-16 15:20:36 -07004625}
4626
4627void
4628nfs4_state_shutdown(void)
4629{
Tejun Heoafe2c512010-12-14 16:21:17 +01004630 cancel_delayed_work_sync(&laundromat_work);
NeilBrown5e8d5c22006-04-10 22:55:37 -07004631 destroy_workqueue(laundry_wq);
J. Bruce Fields2c5e7612008-11-20 14:36:17 -06004632 locks_end_grace(&nfsd4_manager);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004633 nfs4_lock_state();
4634 nfs4_release_reclaim();
4635 __nfs4_state_shutdown();
Linus Torvalds1da177e2005-04-16 15:20:36 -07004636 nfs4_unlock_state();
J. Bruce Fieldsc3935e32010-06-04 16:42:08 -04004637 nfsd4_destroy_callback_queue();
Linus Torvalds1da177e2005-04-16 15:20:36 -07004638}
4639
Jeff Layton3dd98a32008-06-10 08:40:36 -04004640/*
4641 * user_recovery_dirname is protected by the nfsd_mutex since it's only
4642 * accessed when nfsd is starting.
4643 */
NeilBrown0964a3d2005-06-23 22:04:32 -07004644static void
4645nfs4_set_recdir(char *recdir)
4646{
NeilBrown0964a3d2005-06-23 22:04:32 -07004647 strcpy(user_recovery_dirname, recdir);
NeilBrown0964a3d2005-06-23 22:04:32 -07004648}
4649
4650/*
4651 * Change the NFSv4 recovery directory to recdir.
4652 */
4653int
4654nfs4_reset_recoverydir(char *recdir)
4655{
4656 int status;
Al Viroa63bb992008-08-02 01:03:36 -04004657 struct path path;
NeilBrown0964a3d2005-06-23 22:04:32 -07004658
Al Viroa63bb992008-08-02 01:03:36 -04004659 status = kern_path(recdir, LOOKUP_FOLLOW, &path);
NeilBrown0964a3d2005-06-23 22:04:32 -07004660 if (status)
4661 return status;
4662 status = -ENOTDIR;
Al Viroa63bb992008-08-02 01:03:36 -04004663 if (S_ISDIR(path.dentry->d_inode->i_mode)) {
NeilBrown0964a3d2005-06-23 22:04:32 -07004664 nfs4_set_recdir(recdir);
4665 status = 0;
4666 }
Al Viroa63bb992008-08-02 01:03:36 -04004667 path_put(&path);
NeilBrown0964a3d2005-06-23 22:04:32 -07004668 return status;
4669}
4670
Jeff Layton3dd98a32008-06-10 08:40:36 -04004671char *
4672nfs4_recoverydir(void)
4673{
4674 return user_recovery_dirname;
4675}