blob: 12f7109720c235cc92cd2464621f7cbff893848e [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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070036#include <linux/smp_lock.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090037#include <linux/slab.h>
NeilBrown0964a3d2005-06-23 22:04:32 -070038#include <linux/namei.h>
Meelap Shahc2f1a552007-07-17 04:04:39 -070039#include <linux/swap.h>
Olga Kornievskaia68e76ad2008-12-23 16:17:15 -050040#include <linux/sunrpc/svcauth_gss.h>
Jeff Layton363168b2009-08-14 12:57:56 -040041#include <linux/sunrpc/clnt.h>
Boaz Harrosh9a74af22009-12-03 20:30:56 +020042#include "xdr4.h"
J. Bruce Fields0a3adad2009-11-04 18:12:35 -050043#include "vfs.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070044
45#define NFSDDBG_FACILITY NFSDDBG_PROC
46
47/* Globals */
J. Bruce Fieldscf07d2e2010-02-28 23:20:19 -050048time_t nfsd4_lease = 90; /* default lease time */
J. Bruce Fieldsefc4bb4f2010-03-02 11:04:06 -050049time_t nfsd4_grace = 90;
NeilBrownfd39ca92005-06-23 22:04:03 -070050static time_t boot_time;
Linus Torvalds1da177e2005-04-16 15:20:36 -070051static u32 current_ownerid = 1;
52static u32 current_fileid = 1;
53static u32 current_delegid = 1;
54static u32 nfs4_init;
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);
Linus Torvalds1da177e2005-04-16 15:20:36 -070064static struct nfs4_delegation * find_delegation_stateid(struct inode *ino, stateid_t *stid);
NeilBrown0964a3d2005-06-23 22:04:32 -070065static char user_recovery_dirname[PATH_MAX] = "/var/lib/nfs/v4recovery";
66static void nfs4_set_recdir(char *recdir);
Linus Torvalds1da177e2005-04-16 15:20:36 -070067
J. Bruce Fields8b671b82009-02-22 14:51:34 -080068/* Locking: */
69
70/* Currently used for almost all code touching nfsv4 state: */
Ingo Molnar353ab6e2006-03-26 01:37:12 -080071static DEFINE_MUTEX(client_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070072
J. Bruce Fields8b671b82009-02-22 14:51:34 -080073/*
74 * Currently used for the del_recall_lru and file hash table. In an
75 * effort to decrease the scope of the client_mutex, this spinlock may
76 * eventually cover more:
77 */
78static DEFINE_SPINLOCK(recall_lock);
79
Christoph Lametere18b8902006-12-06 20:33:20 -080080static struct kmem_cache *stateowner_slab = NULL;
81static struct kmem_cache *file_slab = NULL;
82static struct kmem_cache *stateid_slab = NULL;
83static struct kmem_cache *deleg_slab = NULL;
NeilBrowne60d4392005-06-23 22:03:01 -070084
Linus Torvalds1da177e2005-04-16 15:20:36 -070085void
86nfs4_lock_state(void)
87{
Ingo Molnar353ab6e2006-03-26 01:37:12 -080088 mutex_lock(&client_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070089}
90
91void
92nfs4_unlock_state(void)
93{
Ingo Molnar353ab6e2006-03-26 01:37:12 -080094 mutex_unlock(&client_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070095}
96
97static inline u32
98opaque_hashval(const void *ptr, int nbytes)
99{
100 unsigned char *cptr = (unsigned char *) ptr;
101
102 u32 x = 0;
103 while (nbytes--) {
104 x *= 37;
105 x += *cptr++;
106 }
107 return x;
108}
109
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110static struct list_head del_recall_lru;
111
NeilBrown13cd2182005-06-23 22:03:10 -0700112static inline void
113put_nfs4_file(struct nfs4_file *fi)
114{
J. Bruce Fields8b671b82009-02-22 14:51:34 -0800115 if (atomic_dec_and_lock(&fi->fi_ref, &recall_lock)) {
116 list_del(&fi->fi_hash);
117 spin_unlock(&recall_lock);
118 iput(fi->fi_inode);
119 kmem_cache_free(file_slab, fi);
120 }
NeilBrown13cd2182005-06-23 22:03:10 -0700121}
122
123static inline void
124get_nfs4_file(struct nfs4_file *fi)
125{
J. Bruce Fields8b671b82009-02-22 14:51:34 -0800126 atomic_inc(&fi->fi_ref);
NeilBrown13cd2182005-06-23 22:03:10 -0700127}
128
NeilBrownef0f3392006-04-10 22:55:41 -0700129static int num_delegations;
Meelap Shahc2f1a552007-07-17 04:04:39 -0700130unsigned int max_delegations;
NeilBrownef0f3392006-04-10 22:55:41 -0700131
132/*
133 * Open owner state (share locks)
134 */
135
136/* hash tables for nfs4_stateowner */
137#define OWNER_HASH_BITS 8
138#define OWNER_HASH_SIZE (1 << OWNER_HASH_BITS)
139#define OWNER_HASH_MASK (OWNER_HASH_SIZE - 1)
140
141#define ownerid_hashval(id) \
142 ((id) & OWNER_HASH_MASK)
143#define ownerstr_hashval(clientid, ownername) \
144 (((clientid) + opaque_hashval((ownername.data), (ownername.len))) & OWNER_HASH_MASK)
145
146static struct list_head ownerid_hashtbl[OWNER_HASH_SIZE];
147static struct list_head ownerstr_hashtbl[OWNER_HASH_SIZE];
148
149/* hash table for nfs4_file */
150#define FILE_HASH_BITS 8
151#define FILE_HASH_SIZE (1 << FILE_HASH_BITS)
152#define FILE_HASH_MASK (FILE_HASH_SIZE - 1)
153/* hash table for (open)nfs4_stateid */
154#define STATEID_HASH_BITS 10
155#define STATEID_HASH_SIZE (1 << STATEID_HASH_BITS)
156#define STATEID_HASH_MASK (STATEID_HASH_SIZE - 1)
157
158#define file_hashval(x) \
159 hash_ptr(x, FILE_HASH_BITS)
160#define stateid_hashval(owner_id, file_id) \
161 (((owner_id) + (file_id)) & STATEID_HASH_MASK)
162
163static struct list_head file_hashtbl[FILE_HASH_SIZE];
164static struct list_head stateid_hashtbl[STATEID_HASH_SIZE];
165
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166static struct nfs4_delegation *
167alloc_init_deleg(struct nfs4_client *clp, struct nfs4_stateid *stp, struct svc_fh *current_fh, u32 type)
168{
169 struct nfs4_delegation *dp;
170 struct nfs4_file *fp = stp->st_file;
J. Bruce Fieldsc237dc02009-04-29 19:09:19 -0400171 struct nfs4_cb_conn *cb = &stp->st_stateowner->so_client->cl_cb_conn;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172
173 dprintk("NFSD alloc_init_deleg\n");
Meelap Shah47f99402007-07-17 04:04:40 -0700174 if (fp->fi_had_conflict)
175 return NULL;
Meelap Shahc2f1a552007-07-17 04:04:39 -0700176 if (num_delegations > max_delegations)
NeilBrownef0f3392006-04-10 22:55:41 -0700177 return NULL;
NeilBrown5b2d21c2005-06-23 22:03:04 -0700178 dp = kmem_cache_alloc(deleg_slab, GFP_KERNEL);
179 if (dp == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180 return dp;
NeilBrownef0f3392006-04-10 22:55:41 -0700181 num_delegations++;
NeilBrownea1da632005-06-23 22:04:17 -0700182 INIT_LIST_HEAD(&dp->dl_perfile);
183 INIT_LIST_HEAD(&dp->dl_perclnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184 INIT_LIST_HEAD(&dp->dl_recall_lru);
185 dp->dl_client = clp;
NeilBrown13cd2182005-06-23 22:03:10 -0700186 get_nfs4_file(fp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187 dp->dl_file = fp;
188 dp->dl_flock = NULL;
189 get_file(stp->st_vfs_file);
190 dp->dl_vfs_file = stp->st_vfs_file;
191 dp->dl_type = type;
J. Bruce Fieldsb53d40c2009-05-01 19:50:00 -0400192 dp->dl_ident = cb->cb_ident;
J. Bruce Fieldse4e83ea2010-04-22 16:21:39 -0400193 dp->dl_stateid.si_boot = boot_time;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194 dp->dl_stateid.si_stateownerid = current_delegid++;
195 dp->dl_stateid.si_fileid = 0;
196 dp->dl_stateid.si_generation = 0;
J. Bruce Fields6c02eaa2009-02-02 17:30:51 -0500197 fh_copy_shallow(&dp->dl_fh, &current_fh->fh_handle);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198 dp->dl_time = 0;
199 atomic_set(&dp->dl_count, 1);
NeilBrownea1da632005-06-23 22:04:17 -0700200 list_add(&dp->dl_perfile, &fp->fi_delegations);
201 list_add(&dp->dl_perclnt, &clp->cl_delegations);
J. Bruce Fieldsb5a1a812010-03-03 14:52:55 -0500202 INIT_WORK(&dp->dl_recall.cb_work, nfsd4_do_callback_rpc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203 return dp;
204}
205
206void
207nfs4_put_delegation(struct nfs4_delegation *dp)
208{
209 if (atomic_dec_and_test(&dp->dl_count)) {
210 dprintk("NFSD: freeing dp %p\n",dp);
NeilBrown13cd2182005-06-23 22:03:10 -0700211 put_nfs4_file(dp->dl_file);
NeilBrown5b2d21c2005-06-23 22:03:04 -0700212 kmem_cache_free(deleg_slab, dp);
NeilBrownef0f3392006-04-10 22:55:41 -0700213 num_delegations--;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214 }
215}
216
217/* Remove the associated file_lock first, then remove the delegation.
218 * lease_modify() is called to remove the FS_LEASE file_lock from
219 * the i_flock list, eventually calling nfsd's lock_manager
220 * fl_release_callback.
221 */
222static void
223nfs4_close_delegation(struct nfs4_delegation *dp)
224{
225 struct file *filp = dp->dl_vfs_file;
226
227 dprintk("NFSD: close_delegation dp %p\n",dp);
228 dp->dl_vfs_file = NULL;
229 /* The following nfsd_close may not actually close the file,
230 * but we want to remove the lease in any case. */
NeilBrownc9071322005-04-16 15:26:38 -0700231 if (dp->dl_flock)
J. Bruce Fieldsa9933ce2007-06-07 17:09:49 -0400232 vfs_setlease(filp, F_UNLCK, &dp->dl_flock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233 nfsd_close(filp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234}
235
236/* Called under the state lock. */
237static void
238unhash_delegation(struct nfs4_delegation *dp)
239{
NeilBrownea1da632005-06-23 22:04:17 -0700240 list_del_init(&dp->dl_perfile);
241 list_del_init(&dp->dl_perclnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242 spin_lock(&recall_lock);
243 list_del_init(&dp->dl_recall_lru);
244 spin_unlock(&recall_lock);
245 nfs4_close_delegation(dp);
246 nfs4_put_delegation(dp);
247}
248
249/*
250 * SETCLIENTID state
251 */
252
Benny Halevy36acb662010-05-12 00:13:04 +0300253/* client_lock protects the client lru list and session hash table */
Benny Halevy9089f1b2010-05-12 00:12:26 +0300254static DEFINE_SPINLOCK(client_lock);
255
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256/* Hash tables for nfs4_clientid state */
257#define CLIENT_HASH_BITS 4
258#define CLIENT_HASH_SIZE (1 << CLIENT_HASH_BITS)
259#define CLIENT_HASH_MASK (CLIENT_HASH_SIZE - 1)
260
261#define clientid_hashval(id) \
262 ((id) & CLIENT_HASH_MASK)
NeilBrowna55370a2005-06-23 22:03:52 -0700263#define clientstr_hashval(name) \
264 (opaque_hashval((name), 8) & CLIENT_HASH_MASK)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265/*
266 * reclaim_str_hashtbl[] holds known client info from previous reset/reboot
267 * used in reboot/reset lease grace period processing
268 *
269 * conf_id_hashtbl[], and conf_str_hashtbl[] hold confirmed
270 * setclientid_confirmed info.
271 *
272 * unconf_str_hastbl[] and unconf_id_hashtbl[] hold unconfirmed
273 * setclientid info.
274 *
275 * client_lru holds client queue ordered by nfs4_client.cl_time
276 * for lease renewal.
277 *
278 * close_lru holds (open) stateowner queue ordered by nfs4_stateowner.so_time
279 * for last close replay.
280 */
281static struct list_head reclaim_str_hashtbl[CLIENT_HASH_SIZE];
282static int reclaim_str_hashtbl_size = 0;
283static struct list_head conf_id_hashtbl[CLIENT_HASH_SIZE];
284static struct list_head conf_str_hashtbl[CLIENT_HASH_SIZE];
285static struct list_head unconf_str_hashtbl[CLIENT_HASH_SIZE];
286static struct list_head unconf_id_hashtbl[CLIENT_HASH_SIZE];
287static struct list_head client_lru;
288static struct list_head close_lru;
289
J. Bruce Fields22839632009-01-11 14:27:17 -0500290static void unhash_generic_stateid(struct nfs4_stateid *stp)
291{
292 list_del(&stp->st_hash);
293 list_del(&stp->st_perfile);
294 list_del(&stp->st_perstateowner);
295}
296
297static void free_generic_stateid(struct nfs4_stateid *stp)
298{
299 put_nfs4_file(stp->st_file);
300 kmem_cache_free(stateid_slab, stp);
301}
302
303static void release_lock_stateid(struct nfs4_stateid *stp)
304{
305 unhash_generic_stateid(stp);
306 locks_remove_posix(stp->st_vfs_file, (fl_owner_t)stp->st_stateowner);
307 free_generic_stateid(stp);
308}
309
J. Bruce Fieldsf044ff82009-01-11 15:24:04 -0500310static void unhash_lockowner(struct nfs4_stateowner *sop)
311{
312 struct nfs4_stateid *stp;
313
314 list_del(&sop->so_idhash);
315 list_del(&sop->so_strhash);
316 list_del(&sop->so_perstateid);
317 while (!list_empty(&sop->so_stateids)) {
318 stp = list_first_entry(&sop->so_stateids,
319 struct nfs4_stateid, st_perstateowner);
320 release_lock_stateid(stp);
321 }
322}
323
324static void release_lockowner(struct nfs4_stateowner *sop)
325{
326 unhash_lockowner(sop);
327 nfs4_put_stateowner(sop);
328}
329
J. Bruce Fieldsf1d110c2009-01-11 14:37:31 -0500330static void
331release_stateid_lockowners(struct nfs4_stateid *open_stp)
332{
333 struct nfs4_stateowner *lock_sop;
334
335 while (!list_empty(&open_stp->st_lockowners)) {
336 lock_sop = list_entry(open_stp->st_lockowners.next,
337 struct nfs4_stateowner, so_perstateid);
338 /* list_del(&open_stp->st_lockowners); */
339 BUG_ON(lock_sop->so_is_open_owner);
J. Bruce Fieldsf044ff82009-01-11 15:24:04 -0500340 release_lockowner(lock_sop);
J. Bruce Fieldsf1d110c2009-01-11 14:37:31 -0500341 }
342}
343
J. Bruce Fields22839632009-01-11 14:27:17 -0500344static void release_open_stateid(struct nfs4_stateid *stp)
345{
346 unhash_generic_stateid(stp);
347 release_stateid_lockowners(stp);
348 nfsd_close(stp->st_vfs_file);
349 free_generic_stateid(stp);
350}
351
J. Bruce Fieldsf044ff82009-01-11 15:24:04 -0500352static void unhash_openowner(struct nfs4_stateowner *sop)
J. Bruce Fieldsf1d110c2009-01-11 14:37:31 -0500353{
354 struct nfs4_stateid *stp;
355
356 list_del(&sop->so_idhash);
357 list_del(&sop->so_strhash);
J. Bruce Fieldsf044ff82009-01-11 15:24:04 -0500358 list_del(&sop->so_perclient);
359 list_del(&sop->so_perstateid); /* XXX: necessary? */
J. Bruce Fieldsf1d110c2009-01-11 14:37:31 -0500360 while (!list_empty(&sop->so_stateids)) {
J. Bruce Fieldsf044ff82009-01-11 15:24:04 -0500361 stp = list_first_entry(&sop->so_stateids,
362 struct nfs4_stateid, st_perstateowner);
363 release_open_stateid(stp);
J. Bruce Fieldsf1d110c2009-01-11 14:37:31 -0500364 }
365}
366
J. Bruce Fieldsf044ff82009-01-11 15:24:04 -0500367static void release_openowner(struct nfs4_stateowner *sop)
J. Bruce Fieldsf1d110c2009-01-11 14:37:31 -0500368{
J. Bruce Fieldsf044ff82009-01-11 15:24:04 -0500369 unhash_openowner(sop);
J. Bruce Fieldsf1d110c2009-01-11 14:37:31 -0500370 list_del(&sop->so_close_lru);
371 nfs4_put_stateowner(sop);
372}
373
Marc Eshel5282fd72009-04-03 08:27:52 +0300374#define SESSION_HASH_SIZE 512
375static struct list_head sessionid_hashtbl[SESSION_HASH_SIZE];
376
377static inline int
378hash_sessionid(struct nfs4_sessionid *sessionid)
379{
380 struct nfsd4_sessionid *sid = (struct nfsd4_sessionid *)sessionid;
381
382 return sid->sequence % SESSION_HASH_SIZE;
383}
384
385static inline void
386dump_sessionid(const char *fn, struct nfs4_sessionid *sessionid)
387{
388 u32 *ptr = (u32 *)(&sessionid->data[0]);
389 dprintk("%s: %u:%u:%u:%u\n", fn, ptr[0], ptr[1], ptr[2], ptr[3]);
390}
391
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300392static void
393gen_sessionid(struct nfsd4_session *ses)
394{
395 struct nfs4_client *clp = ses->se_client;
396 struct nfsd4_sessionid *sid;
397
398 sid = (struct nfsd4_sessionid *)ses->se_sessionid.data;
399 sid->clientid = clp->cl_clientid;
400 sid->sequence = current_sessionid++;
401 sid->reserved = 0;
402}
403
404/*
Andy Adamsona6496372009-08-28 08:45:01 -0400405 * The protocol defines ca_maxresponssize_cached to include the size of
406 * the rpc header, but all we need to cache is the data starting after
407 * the end of the initial SEQUENCE operation--the rest we regenerate
408 * each time. Therefore we can advertise a ca_maxresponssize_cached
409 * value that is the number of bytes in our cache plus a few additional
410 * bytes. In order to stay on the safe side, and not promise more than
411 * we can cache, those additional bytes must be the minimum possible: 24
412 * bytes of rpc header (xid through accept state, with AUTH_NULL
413 * verifier), 12 for the compound header (with zero-length tag), and 44
414 * for the SEQUENCE op response:
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300415 */
Andy Adamsona6496372009-08-28 08:45:01 -0400416#define NFSD_MIN_HDR_SEQ_SZ (24 + 12 + 44)
417
418/*
419 * Give the client the number of ca_maxresponsesize_cached slots it
420 * requests, of size bounded by NFSD_SLOT_CACHE_SIZE,
421 * NFSD_MAX_MEM_PER_SESSION, and nfsd_drc_max_mem. Do not allow more
422 * than NFSD_MAX_SLOTS_PER_SESSION.
423 *
424 * If we run out of reserved DRC memory we should (up to a point)
425 * re-negotiate active sessions and reduce their slot usage to make
426 * rooom for new connections. For now we just fail the create session.
427 */
428static int set_forechannel_drc_size(struct nfsd4_channel_attrs *fchan)
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300429{
Andy Adamsona6496372009-08-28 08:45:01 -0400430 int mem, size = fchan->maxresp_cached;
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300431
Andy Adamson5d77ddf2009-06-16 04:19:38 +0300432 if (fchan->maxreqs < 1)
433 return nfserr_inval;
Andy Adamson5d77ddf2009-06-16 04:19:38 +0300434
Andy Adamsona6496372009-08-28 08:45:01 -0400435 if (size < NFSD_MIN_HDR_SEQ_SZ)
436 size = NFSD_MIN_HDR_SEQ_SZ;
437 size -= NFSD_MIN_HDR_SEQ_SZ;
438 if (size > NFSD_SLOT_CACHE_SIZE)
439 size = NFSD_SLOT_CACHE_SIZE;
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300440
Andy Adamsona6496372009-08-28 08:45:01 -0400441 /* bound the maxreqs by NFSD_MAX_MEM_PER_SESSION */
442 mem = fchan->maxreqs * size;
443 if (mem > NFSD_MAX_MEM_PER_SESSION) {
444 fchan->maxreqs = NFSD_MAX_MEM_PER_SESSION / size;
445 if (fchan->maxreqs > NFSD_MAX_SLOTS_PER_SESSION)
446 fchan->maxreqs = NFSD_MAX_SLOTS_PER_SESSION;
447 mem = fchan->maxreqs * size;
448 }
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300449
Andy Adamson4bd9b0f42009-06-24 15:37:45 -0400450 spin_lock(&nfsd_drc_lock);
Andy Adamsona6496372009-08-28 08:45:01 -0400451 /* bound the total session drc memory ussage */
452 if (mem + nfsd_drc_mem_used > nfsd_drc_max_mem) {
453 fchan->maxreqs = (nfsd_drc_max_mem - nfsd_drc_mem_used) / size;
454 mem = fchan->maxreqs * size;
455 }
Andy Adamson0c193052009-07-27 19:09:19 -0400456 nfsd_drc_mem_used += mem;
Andy Adamson4bd9b0f42009-06-24 15:37:45 -0400457 spin_unlock(&nfsd_drc_lock);
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300458
Andy Adamsonb101ebb2009-07-27 18:40:09 -0400459 if (fchan->maxreqs == 0)
Andy Adamsonbdac86e2009-08-28 08:45:03 -0400460 return nfserr_serverfault;
Andy Adamsona6496372009-08-28 08:45:01 -0400461
462 fchan->maxresp_cached = size + NFSD_MIN_HDR_SEQ_SZ;
Andy Adamsonb101ebb2009-07-27 18:40:09 -0400463 return 0;
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300464}
465
466/*
467 * fchan holds the client values on input, and the server values on output
Andy Adamsonddc04fd2009-09-23 21:32:21 -0400468 * sv_max_mesg is the maximum payload plus one page for overhead.
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300469 */
470static int init_forechannel_attrs(struct svc_rqst *rqstp,
Alexandros Batsakis6c18ba92009-06-16 04:19:13 +0300471 struct nfsd4_channel_attrs *session_fchan,
472 struct nfsd4_channel_attrs *fchan)
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300473{
474 int status = 0;
Andy Adamsonddc04fd2009-09-23 21:32:21 -0400475 __u32 maxcount = nfsd_serv->sv_max_mesg;
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300476
477 /* headerpadsz set to zero in encode routine */
478
479 /* Use the client's max request and max response size if possible */
480 if (fchan->maxreq_sz > maxcount)
481 fchan->maxreq_sz = maxcount;
Alexandros Batsakis6c18ba92009-06-16 04:19:13 +0300482 session_fchan->maxreq_sz = fchan->maxreq_sz;
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300483
484 if (fchan->maxresp_sz > maxcount)
485 fchan->maxresp_sz = maxcount;
Alexandros Batsakis6c18ba92009-06-16 04:19:13 +0300486 session_fchan->maxresp_sz = fchan->maxresp_sz;
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300487
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300488 /* Use the client's maxops if possible */
489 if (fchan->maxops > NFSD_MAX_OPS_PER_COMPOUND)
490 fchan->maxops = NFSD_MAX_OPS_PER_COMPOUND;
Alexandros Batsakis6c18ba92009-06-16 04:19:13 +0300491 session_fchan->maxops = fchan->maxops;
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300492
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300493 /* FIXME: Error means no more DRC pages so the server should
494 * recover pages from existing sessions. For now fail session
495 * creation.
496 */
Andy Adamsona6496372009-08-28 08:45:01 -0400497 status = set_forechannel_drc_size(fchan);
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300498
Andy Adamsona6496372009-08-28 08:45:01 -0400499 session_fchan->maxresp_cached = fchan->maxresp_cached;
Alexandros Batsakis6c18ba92009-06-16 04:19:13 +0300500 session_fchan->maxreqs = fchan->maxreqs;
Andy Adamsona6496372009-08-28 08:45:01 -0400501
502 dprintk("%s status %d\n", __func__, status);
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300503 return status;
504}
505
Andy Adamson557ce262009-08-28 08:45:04 -0400506static void
507free_session_slots(struct nfsd4_session *ses)
508{
509 int i;
510
511 for (i = 0; i < ses->se_fchannel.maxreqs; i++)
512 kfree(ses->se_slots[i]);
513}
514
J. Bruce Fieldsefe0cb62009-10-24 20:52:16 -0400515/*
516 * We don't actually need to cache the rpc and session headers, so we
517 * can allocate a little less for each slot:
518 */
519static inline int slot_bytes(struct nfsd4_channel_attrs *ca)
520{
521 return ca->maxresp_cached - NFSD_MIN_HDR_SEQ_SZ;
522}
523
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300524static int
525alloc_init_session(struct svc_rqst *rqstp, struct nfs4_client *clp,
526 struct nfsd4_create_session *cses)
527{
528 struct nfsd4_session *new, tmp;
Andy Adamson557ce262009-08-28 08:45:04 -0400529 struct nfsd4_slot *sp;
530 int idx, slotsize, cachesize, i;
531 int status;
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300532
533 memset(&tmp, 0, sizeof(tmp));
534
535 /* FIXME: For now, we just accept the client back channel attributes. */
Alexandros Batsakis6c18ba92009-06-16 04:19:13 +0300536 tmp.se_bchannel = cses->back_channel;
537 status = init_forechannel_attrs(rqstp, &tmp.se_fchannel,
538 &cses->fore_channel);
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300539 if (status)
540 goto out;
541
Andy Adamson557ce262009-08-28 08:45:04 -0400542 BUILD_BUG_ON(NFSD_MAX_SLOTS_PER_SESSION * sizeof(struct nfsd4_slot)
543 + sizeof(struct nfsd4_session) > PAGE_SIZE);
544
545 status = nfserr_serverfault;
546 /* allocate struct nfsd4_session and slot table pointers in one piece */
547 slotsize = tmp.se_fchannel.maxreqs * sizeof(struct nfsd4_slot *);
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300548 new = kzalloc(sizeof(*new) + slotsize, GFP_KERNEL);
549 if (!new)
550 goto out;
551
552 memcpy(new, &tmp, sizeof(*new));
553
Andy Adamson557ce262009-08-28 08:45:04 -0400554 /* allocate each struct nfsd4_slot and data cache in one piece */
J. Bruce Fieldsefe0cb62009-10-24 20:52:16 -0400555 cachesize = slot_bytes(&new->se_fchannel);
Andy Adamson557ce262009-08-28 08:45:04 -0400556 for (i = 0; i < new->se_fchannel.maxreqs; i++) {
557 sp = kzalloc(sizeof(*sp) + cachesize, GFP_KERNEL);
558 if (!sp)
559 goto out_free;
560 new->se_slots[i] = sp;
561 }
562
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300563 new->se_client = clp;
564 gen_sessionid(new);
565 idx = hash_sessionid(&new->se_sessionid);
566 memcpy(clp->cl_sessionid.data, new->se_sessionid.data,
567 NFS4_MAX_SESSIONID_LEN);
568
569 new->se_flags = cses->flags;
570 kref_init(&new->se_ref);
Benny Halevy9089f1b2010-05-12 00:12:26 +0300571 spin_lock(&client_lock);
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300572 list_add(&new->se_hash, &sessionid_hashtbl[idx]);
573 list_add(&new->se_perclnt, &clp->cl_sessions);
Benny Halevy9089f1b2010-05-12 00:12:26 +0300574 spin_unlock(&client_lock);
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300575
576 status = nfs_ok;
577out:
578 return status;
Andy Adamson557ce262009-08-28 08:45:04 -0400579out_free:
580 free_session_slots(new);
581 kfree(new);
582 goto out;
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300583}
584
Benny Halevy9089f1b2010-05-12 00:12:26 +0300585/* caller must hold client_lock */
Marc Eshel5282fd72009-04-03 08:27:52 +0300586static struct nfsd4_session *
587find_in_sessionid_hashtbl(struct nfs4_sessionid *sessionid)
588{
589 struct nfsd4_session *elem;
590 int idx;
591
592 dump_sessionid(__func__, sessionid);
593 idx = hash_sessionid(sessionid);
594 dprintk("%s: idx is %d\n", __func__, idx);
595 /* Search in the appropriate list */
596 list_for_each_entry(elem, &sessionid_hashtbl[idx], se_hash) {
597 dump_sessionid("list traversal", &elem->se_sessionid);
598 if (!memcmp(elem->se_sessionid.data, sessionid->data,
599 NFS4_MAX_SESSIONID_LEN)) {
600 return elem;
601 }
602 }
603
604 dprintk("%s: session not found\n", __func__);
605 return NULL;
606}
607
Benny Halevy9089f1b2010-05-12 00:12:26 +0300608/* caller must hold client_lock */
Andy Adamson7116ed62009-04-03 08:27:43 +0300609static void
Marc Eshel5282fd72009-04-03 08:27:52 +0300610unhash_session(struct nfsd4_session *ses)
Andy Adamson7116ed62009-04-03 08:27:43 +0300611{
612 list_del(&ses->se_hash);
613 list_del(&ses->se_perclnt);
Marc Eshel5282fd72009-04-03 08:27:52 +0300614}
615
Andy Adamson7116ed62009-04-03 08:27:43 +0300616void
617free_session(struct kref *kref)
618{
619 struct nfsd4_session *ses;
J. Bruce Fieldsdd829c42009-10-21 17:54:13 -0400620 int mem;
Andy Adamson7116ed62009-04-03 08:27:43 +0300621
622 ses = container_of(kref, struct nfsd4_session, se_ref);
Andy Adamsonbe98d1b2009-07-27 18:49:05 -0400623 spin_lock(&nfsd_drc_lock);
J. Bruce Fieldsefe0cb62009-10-24 20:52:16 -0400624 mem = ses->se_fchannel.maxreqs * slot_bytes(&ses->se_fchannel);
J. Bruce Fieldsdd829c42009-10-21 17:54:13 -0400625 nfsd_drc_mem_used -= mem;
Andy Adamsonbe98d1b2009-07-27 18:49:05 -0400626 spin_unlock(&nfsd_drc_lock);
Andy Adamson557ce262009-08-28 08:45:04 -0400627 free_session_slots(ses);
Andy Adamson7116ed62009-04-03 08:27:43 +0300628 kfree(ses);
629}
630
Benny Halevy36acb662010-05-12 00:13:04 +0300631/* must be called under the client_lock */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700632static inline void
Benny Halevy36acb662010-05-12 00:13:04 +0300633renew_client_locked(struct nfs4_client *clp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700634{
Benny Halevy07cd4902010-05-12 00:13:41 +0300635 if (is_client_expired(clp)) {
636 dprintk("%s: client (clientid %08x/%08x) already expired\n",
637 __func__,
638 clp->cl_clientid.cl_boot,
639 clp->cl_clientid.cl_id);
640 return;
641 }
642
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643 /*
644 * Move client to the end to the LRU list.
645 */
646 dprintk("renewing client (clientid %08x/%08x)\n",
647 clp->cl_clientid.cl_boot,
648 clp->cl_clientid.cl_id);
649 list_move_tail(&clp->cl_lru, &client_lru);
650 clp->cl_time = get_seconds();
651}
652
Benny Halevy36acb662010-05-12 00:13:04 +0300653static inline void
654renew_client(struct nfs4_client *clp)
655{
656 spin_lock(&client_lock);
657 renew_client_locked(clp);
658 spin_unlock(&client_lock);
659}
660
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661/* SETCLIENTID and SETCLIENTID_CONFIRM Helper functions */
662static int
663STALE_CLIENTID(clientid_t *clid)
664{
665 if (clid->cl_boot == boot_time)
666 return 0;
Andy Adamson60adfc52009-04-03 08:28:50 +0300667 dprintk("NFSD stale clientid (%08x/%08x) boot_time %08lx\n",
668 clid->cl_boot, clid->cl_id, boot_time);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700669 return 1;
670}
671
672/*
673 * XXX Should we use a slab cache ?
674 * This type of memory management is somewhat inefficient, but we use it
675 * anyway since SETCLIENTID is not a common operation.
676 */
J. Bruce Fields35bba9a2007-11-21 22:07:08 -0500677static struct nfs4_client *alloc_client(struct xdr_netobj name)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700678{
679 struct nfs4_client *clp;
680
J. Bruce Fields35bba9a2007-11-21 22:07:08 -0500681 clp = kzalloc(sizeof(struct nfs4_client), GFP_KERNEL);
682 if (clp == NULL)
683 return NULL;
684 clp->cl_name.data = kmalloc(name.len, GFP_KERNEL);
685 if (clp->cl_name.data == NULL) {
686 kfree(clp);
687 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700688 }
J. Bruce Fields35bba9a2007-11-21 22:07:08 -0500689 memcpy(clp->cl_name.data, name.data, name.len);
690 clp->cl_name.len = name.len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691 return clp;
692}
693
694static inline void
695free_client(struct nfs4_client *clp)
696{
697 if (clp->cl_cred.cr_group_info)
698 put_group_info(clp->cl_cred.cr_group_info);
Olga Kornievskaia68e76ad2008-12-23 16:17:15 -0500699 kfree(clp->cl_principal);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700 kfree(clp->cl_name.data);
701 kfree(clp);
702}
703
Benny Halevyd7682982010-05-12 00:13:54 +0300704void
705release_session_client(struct nfsd4_session *session)
706{
707 struct nfs4_client *clp = session->se_client;
708
709 if (!atomic_dec_and_lock(&clp->cl_refcount, &client_lock))
710 return;
711 if (is_client_expired(clp)) {
712 free_client(clp);
713 session->se_client = NULL;
714 } else
715 renew_client_locked(clp);
716 spin_unlock(&client_lock);
717 nfsd4_put_session(session);
718}
719
Benny Halevy84d38ac2010-05-12 00:13:16 +0300720/* must be called under the client_lock */
721static inline void
722unhash_client_locked(struct nfs4_client *clp)
723{
Benny Halevy07cd4902010-05-12 00:13:41 +0300724 mark_client_expired(clp);
Benny Halevy84d38ac2010-05-12 00:13:16 +0300725 list_del(&clp->cl_lru);
726 while (!list_empty(&clp->cl_sessions)) {
727 struct nfsd4_session *ses;
728 ses = list_entry(clp->cl_sessions.next, struct nfsd4_session,
729 se_perclnt);
730 unhash_session(ses);
731 nfsd4_put_session(ses);
732 }
733}
734
Linus Torvalds1da177e2005-04-16 15:20:36 -0700735static void
736expire_client(struct nfs4_client *clp)
737{
738 struct nfs4_stateowner *sop;
739 struct nfs4_delegation *dp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700740 struct list_head reaplist;
741
Linus Torvalds1da177e2005-04-16 15:20:36 -0700742 INIT_LIST_HEAD(&reaplist);
743 spin_lock(&recall_lock);
NeilBrownea1da632005-06-23 22:04:17 -0700744 while (!list_empty(&clp->cl_delegations)) {
745 dp = list_entry(clp->cl_delegations.next, struct nfs4_delegation, dl_perclnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700746 dprintk("NFSD: expire client. dp %p, fp %p\n", dp,
747 dp->dl_flock);
NeilBrownea1da632005-06-23 22:04:17 -0700748 list_del_init(&dp->dl_perclnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700749 list_move(&dp->dl_recall_lru, &reaplist);
750 }
751 spin_unlock(&recall_lock);
752 while (!list_empty(&reaplist)) {
753 dp = list_entry(reaplist.next, struct nfs4_delegation, dl_recall_lru);
754 list_del_init(&dp->dl_recall_lru);
755 unhash_delegation(dp);
756 }
NeilBrownea1da632005-06-23 22:04:17 -0700757 while (!list_empty(&clp->cl_openowners)) {
758 sop = list_entry(clp->cl_openowners.next, struct nfs4_stateowner, so_perclient);
J. Bruce Fieldsf044ff82009-01-11 15:24:04 -0500759 release_openowner(sop);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760 }
J. Bruce Fieldsb5a1a812010-03-03 14:52:55 -0500761 nfsd4_set_callback_client(clp, NULL);
J. Bruce Fields2bf23872010-03-08 12:37:27 -0500762 if (clp->cl_cb_conn.cb_xprt)
763 svc_xprt_put(clp->cl_cb_conn.cb_xprt);
Benny Halevy84d38ac2010-05-12 00:13:16 +0300764 list_del(&clp->cl_idhash);
765 list_del(&clp->cl_strhash);
766 spin_lock(&client_lock);
767 unhash_client_locked(clp);
Benny Halevy46583e22010-05-12 00:13:29 +0300768 if (atomic_read(&clp->cl_refcount) == 0)
769 free_client(clp);
Benny Halevy84d38ac2010-05-12 00:13:16 +0300770 spin_unlock(&client_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700771}
772
J. Bruce Fields35bba9a2007-11-21 22:07:08 -0500773static void copy_verf(struct nfs4_client *target, nfs4_verifier *source)
774{
775 memcpy(target->cl_verifier.data, source->data,
776 sizeof(target->cl_verifier.data));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700777}
778
J. Bruce Fields35bba9a2007-11-21 22:07:08 -0500779static void copy_clid(struct nfs4_client *target, struct nfs4_client *source)
780{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700781 target->cl_clientid.cl_boot = source->cl_clientid.cl_boot;
782 target->cl_clientid.cl_id = source->cl_clientid.cl_id;
783}
784
J. Bruce Fields35bba9a2007-11-21 22:07:08 -0500785static void copy_cred(struct svc_cred *target, struct svc_cred *source)
786{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700787 target->cr_uid = source->cr_uid;
788 target->cr_gid = source->cr_gid;
789 target->cr_group_info = source->cr_group_info;
790 get_group_info(target->cr_group_info);
791}
792
J. Bruce Fields35bba9a2007-11-21 22:07:08 -0500793static int same_name(const char *n1, const char *n2)
J. Bruce Fields599e0a22007-07-26 17:04:54 -0400794{
NeilBrowna55370a2005-06-23 22:03:52 -0700795 return 0 == memcmp(n1, n2, HEXDIR_LEN);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700796}
797
798static int
J. Bruce Fields599e0a22007-07-26 17:04:54 -0400799same_verf(nfs4_verifier *v1, nfs4_verifier *v2)
800{
801 return 0 == memcmp(v1->data, v2->data, sizeof(v1->data));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700802}
803
804static int
J. Bruce Fields599e0a22007-07-26 17:04:54 -0400805same_clid(clientid_t *cl1, clientid_t *cl2)
806{
807 return (cl1->cl_boot == cl2->cl_boot) && (cl1->cl_id == cl2->cl_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700808}
809
810/* XXX what about NGROUP */
811static int
J. Bruce Fields599e0a22007-07-26 17:04:54 -0400812same_creds(struct svc_cred *cr1, struct svc_cred *cr2)
813{
814 return cr1->cr_uid == cr2->cr_uid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700815}
816
J. Bruce Fields5ec7b462007-11-21 21:58:56 -0500817static void gen_clid(struct nfs4_client *clp)
818{
819 static u32 current_clientid = 1;
820
Linus Torvalds1da177e2005-04-16 15:20:36 -0700821 clp->cl_clientid.cl_boot = boot_time;
822 clp->cl_clientid.cl_id = current_clientid++;
823}
824
J. Bruce Fieldsdeda2fa2007-11-19 20:31:04 -0500825static void gen_confirm(struct nfs4_client *clp)
826{
827 static u32 i;
828 u32 *p;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700829
Linus Torvalds1da177e2005-04-16 15:20:36 -0700830 p = (u32 *)clp->cl_confirm.data;
J. Bruce Fieldsdeda2fa2007-11-19 20:31:04 -0500831 *p++ = get_seconds();
832 *p++ = i++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700833}
834
Ricardo Labiagab09333c2009-09-10 12:27:34 +0300835static struct nfs4_client *create_client(struct xdr_netobj name, char *recdir,
836 struct svc_rqst *rqstp, nfs4_verifier *verf)
837{
838 struct nfs4_client *clp;
839 struct sockaddr *sa = svc_addr(rqstp);
840 char *princ;
841
842 clp = alloc_client(name);
843 if (clp == NULL)
844 return NULL;
845
846 princ = svc_gss_principal(rqstp);
847 if (princ) {
848 clp->cl_principal = kstrdup(princ, GFP_KERNEL);
849 if (clp->cl_principal == NULL) {
850 free_client(clp);
851 return NULL;
852 }
853 }
854
855 memcpy(clp->cl_recdir, recdir, HEXDIR_LEN);
Benny Halevy46583e22010-05-12 00:13:29 +0300856 atomic_set(&clp->cl_refcount, 0);
J. Bruce Fields2bf23872010-03-08 12:37:27 -0500857 atomic_set(&clp->cl_cb_set, 0);
Ricardo Labiagab09333c2009-09-10 12:27:34 +0300858 INIT_LIST_HEAD(&clp->cl_idhash);
859 INIT_LIST_HEAD(&clp->cl_strhash);
860 INIT_LIST_HEAD(&clp->cl_openowners);
861 INIT_LIST_HEAD(&clp->cl_delegations);
862 INIT_LIST_HEAD(&clp->cl_sessions);
863 INIT_LIST_HEAD(&clp->cl_lru);
Benny Halevy07cd4902010-05-12 00:13:41 +0300864 clp->cl_time = get_seconds();
Ricardo Labiagab09333c2009-09-10 12:27:34 +0300865 clear_bit(0, &clp->cl_cb_slot_busy);
866 rpc_init_wait_queue(&clp->cl_cb_waitq, "Backchannel slot table");
867 copy_verf(clp, verf);
868 rpc_copy_addr((struct sockaddr *) &clp->cl_addr, sa);
869 clp->cl_flavor = rqstp->rq_flavor;
870 copy_cred(&clp->cl_cred, &rqstp->rq_cred);
871 gen_confirm(clp);
872
873 return clp;
874}
875
J. Bruce Fields35bba9a2007-11-21 22:07:08 -0500876static int check_name(struct xdr_netobj name)
877{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700878 if (name.len == 0)
879 return 0;
880 if (name.len > NFS4_OPAQUE_LIMIT) {
J. Bruce Fields2fdada02007-07-27 16:10:37 -0400881 dprintk("NFSD: check_name: name too long(%d)!\n", name.len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700882 return 0;
883 }
884 return 1;
885}
886
NeilBrownfd39ca92005-06-23 22:04:03 -0700887static void
Linus Torvalds1da177e2005-04-16 15:20:36 -0700888add_to_unconfirmed(struct nfs4_client *clp, unsigned int strhashval)
889{
890 unsigned int idhashval;
891
892 list_add(&clp->cl_strhash, &unconf_str_hashtbl[strhashval]);
893 idhashval = clientid_hashval(clp->cl_clientid.cl_id);
894 list_add(&clp->cl_idhash, &unconf_id_hashtbl[idhashval]);
Benny Halevy36acb662010-05-12 00:13:04 +0300895 renew_client(clp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700896}
897
NeilBrownfd39ca92005-06-23 22:04:03 -0700898static void
Linus Torvalds1da177e2005-04-16 15:20:36 -0700899move_to_confirmed(struct nfs4_client *clp)
900{
901 unsigned int idhashval = clientid_hashval(clp->cl_clientid.cl_id);
902 unsigned int strhashval;
903
904 dprintk("NFSD: move_to_confirm nfs4_client %p\n", clp);
Akinobu Mitaf1166292006-06-26 00:24:46 -0700905 list_move(&clp->cl_idhash, &conf_id_hashtbl[idhashval]);
NeilBrowna55370a2005-06-23 22:03:52 -0700906 strhashval = clientstr_hashval(clp->cl_recdir);
Benny Halevy328efba2010-05-12 00:12:51 +0300907 list_move(&clp->cl_strhash, &conf_str_hashtbl[strhashval]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700908 renew_client(clp);
909}
910
911static struct nfs4_client *
912find_confirmed_client(clientid_t *clid)
913{
914 struct nfs4_client *clp;
915 unsigned int idhashval = clientid_hashval(clid->cl_id);
916
917 list_for_each_entry(clp, &conf_id_hashtbl[idhashval], cl_idhash) {
J. Bruce Fields599e0a22007-07-26 17:04:54 -0400918 if (same_clid(&clp->cl_clientid, clid))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700919 return clp;
920 }
921 return NULL;
922}
923
924static struct nfs4_client *
925find_unconfirmed_client(clientid_t *clid)
926{
927 struct nfs4_client *clp;
928 unsigned int idhashval = clientid_hashval(clid->cl_id);
929
930 list_for_each_entry(clp, &unconf_id_hashtbl[idhashval], cl_idhash) {
J. Bruce Fields599e0a22007-07-26 17:04:54 -0400931 if (same_clid(&clp->cl_clientid, clid))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700932 return clp;
933 }
934 return NULL;
935}
936
Andy Adamsona1bcecd2009-04-03 08:28:05 +0300937/*
938 * Return 1 iff clp's clientid establishment method matches the use_exchange_id
939 * parameter. Matching is based on the fact the at least one of the
940 * EXCHGID4_FLAG_USE_{NON_PNFS,PNFS_MDS,PNFS_DS} flags must be set for v4.1
941 *
942 * FIXME: we need to unify the clientid namespaces for nfsv4.x
943 * and correctly deal with client upgrade/downgrade in EXCHANGE_ID
944 * and SET_CLIENTID{,_CONFIRM}
945 */
946static inline int
947match_clientid_establishment(struct nfs4_client *clp, bool use_exchange_id)
948{
949 bool has_exchange_flags = (clp->cl_exchange_flags != 0);
950 return use_exchange_id == has_exchange_flags;
951}
952
NeilBrown28ce6052005-06-23 22:03:56 -0700953static struct nfs4_client *
Andy Adamsona1bcecd2009-04-03 08:28:05 +0300954find_confirmed_client_by_str(const char *dname, unsigned int hashval,
955 bool use_exchange_id)
NeilBrown28ce6052005-06-23 22:03:56 -0700956{
957 struct nfs4_client *clp;
958
959 list_for_each_entry(clp, &conf_str_hashtbl[hashval], cl_strhash) {
Andy Adamsona1bcecd2009-04-03 08:28:05 +0300960 if (same_name(clp->cl_recdir, dname) &&
961 match_clientid_establishment(clp, use_exchange_id))
NeilBrown28ce6052005-06-23 22:03:56 -0700962 return clp;
963 }
964 return NULL;
965}
966
967static struct nfs4_client *
Andy Adamsona1bcecd2009-04-03 08:28:05 +0300968find_unconfirmed_client_by_str(const char *dname, unsigned int hashval,
969 bool use_exchange_id)
NeilBrown28ce6052005-06-23 22:03:56 -0700970{
971 struct nfs4_client *clp;
972
973 list_for_each_entry(clp, &unconf_str_hashtbl[hashval], cl_strhash) {
Andy Adamsona1bcecd2009-04-03 08:28:05 +0300974 if (same_name(clp->cl_recdir, dname) &&
975 match_clientid_establishment(clp, use_exchange_id))
NeilBrown28ce6052005-06-23 22:03:56 -0700976 return clp;
977 }
978 return NULL;
979}
980
NeilBrownfd39ca92005-06-23 22:04:03 -0700981static void
Jeff Laytonfbf46652009-08-14 12:57:59 -0400982gen_callback(struct nfs4_client *clp, struct nfsd4_setclientid *se, u32 scopeid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700983{
J. Bruce Fieldsc237dc02009-04-29 19:09:19 -0400984 struct nfs4_cb_conn *cb = &clp->cl_cb_conn;
Jeff Layton7077ecb2009-08-14 12:57:58 -0400985 unsigned short expected_family;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700986
Jeff Layton7077ecb2009-08-14 12:57:58 -0400987 /* Currently, we only support tcp and tcp6 for the callback channel */
988 if (se->se_callback_netid_len == 3 &&
989 !memcmp(se->se_callback_netid_val, "tcp", 3))
990 expected_family = AF_INET;
991 else if (se->se_callback_netid_len == 4 &&
992 !memcmp(se->se_callback_netid_val, "tcp6", 4))
993 expected_family = AF_INET6;
994 else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700995 goto out_err;
996
Jeff Laytonaa9a4ec2009-08-14 12:57:57 -0400997 cb->cb_addrlen = rpc_uaddr2sockaddr(se->se_callback_addr_val,
998 se->se_callback_addr_len,
999 (struct sockaddr *) &cb->cb_addr,
1000 sizeof(cb->cb_addr));
1001
Jeff Layton7077ecb2009-08-14 12:57:58 -04001002 if (!cb->cb_addrlen || cb->cb_addr.ss_family != expected_family)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001003 goto out_err;
Jeff Laytonaa9a4ec2009-08-14 12:57:57 -04001004
Jeff Laytonfbf46652009-08-14 12:57:59 -04001005 if (cb->cb_addr.ss_family == AF_INET6)
1006 ((struct sockaddr_in6 *) &cb->cb_addr)->sin6_scope_id = scopeid;
1007
Andy Adamsonab52ae62009-06-16 04:20:53 +03001008 cb->cb_minorversion = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001009 cb->cb_prog = se->se_callback_prog;
1010 cb->cb_ident = se->se_callback_ident;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001011 return;
1012out_err:
Jeff Laytonaa9a4ec2009-08-14 12:57:57 -04001013 cb->cb_addr.ss_family = AF_UNSPEC;
1014 cb->cb_addrlen = 0;
Neil Brown849823c2005-09-13 01:25:36 -07001015 dprintk(KERN_INFO "NFSD: this client (clientid %08x/%08x) "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001016 "will not receive delegations\n",
1017 clp->cl_clientid.cl_boot, clp->cl_clientid.cl_id);
1018
Linus Torvalds1da177e2005-04-16 15:20:36 -07001019 return;
1020}
1021
Andy Adamson074fe892009-04-03 08:28:15 +03001022/*
Andy Adamson557ce262009-08-28 08:45:04 -04001023 * Cache a reply. nfsd4_check_drc_limit() has bounded the cache size.
Andy Adamson074fe892009-04-03 08:28:15 +03001024 */
1025void
1026nfsd4_store_cache_entry(struct nfsd4_compoundres *resp)
1027{
Andy Adamson557ce262009-08-28 08:45:04 -04001028 struct nfsd4_slot *slot = resp->cstate.slot;
1029 unsigned int base;
Andy Adamson074fe892009-04-03 08:28:15 +03001030
Andy Adamson557ce262009-08-28 08:45:04 -04001031 dprintk("--> %s slot %p\n", __func__, slot);
Andy Adamson074fe892009-04-03 08:28:15 +03001032
Andy Adamson557ce262009-08-28 08:45:04 -04001033 slot->sl_opcnt = resp->opcnt;
1034 slot->sl_status = resp->cstate.status;
Andy Adamsonbf864a32009-04-03 08:28:35 +03001035
1036 if (nfsd4_not_cached(resp)) {
Andy Adamson557ce262009-08-28 08:45:04 -04001037 slot->sl_datalen = 0;
Andy Adamsonbf864a32009-04-03 08:28:35 +03001038 return;
1039 }
Andy Adamson557ce262009-08-28 08:45:04 -04001040 slot->sl_datalen = (char *)resp->p - (char *)resp->cstate.datap;
1041 base = (char *)resp->cstate.datap -
1042 (char *)resp->xbuf->head[0].iov_base;
1043 if (read_bytes_from_xdr_buf(resp->xbuf, base, slot->sl_data,
1044 slot->sl_datalen))
1045 WARN("%s: sessions DRC could not cache compound\n", __func__);
1046 return;
Andy Adamson074fe892009-04-03 08:28:15 +03001047}
1048
1049/*
Andy Adamsonabfabf82009-07-23 19:02:18 -04001050 * Encode the replay sequence operation from the slot values.
1051 * If cachethis is FALSE encode the uncached rep error on the next
1052 * operation which sets resp->p and increments resp->opcnt for
1053 * nfs4svc_encode_compoundres.
1054 *
Andy Adamson074fe892009-04-03 08:28:15 +03001055 */
Andy Adamsonabfabf82009-07-23 19:02:18 -04001056static __be32
1057nfsd4_enc_sequence_replay(struct nfsd4_compoundargs *args,
1058 struct nfsd4_compoundres *resp)
Andy Adamson074fe892009-04-03 08:28:15 +03001059{
Andy Adamsonabfabf82009-07-23 19:02:18 -04001060 struct nfsd4_op *op;
1061 struct nfsd4_slot *slot = resp->cstate.slot;
Andy Adamson074fe892009-04-03 08:28:15 +03001062
Andy Adamsonabfabf82009-07-23 19:02:18 -04001063 dprintk("--> %s resp->opcnt %d cachethis %u \n", __func__,
Andy Adamson557ce262009-08-28 08:45:04 -04001064 resp->opcnt, resp->cstate.slot->sl_cachethis);
Andy Adamsonabfabf82009-07-23 19:02:18 -04001065
1066 /* Encode the replayed sequence operation */
1067 op = &args->ops[resp->opcnt - 1];
1068 nfsd4_encode_operation(resp, op);
1069
1070 /* Return nfserr_retry_uncached_rep in next operation. */
Andy Adamson557ce262009-08-28 08:45:04 -04001071 if (args->opcnt > 1 && slot->sl_cachethis == 0) {
Andy Adamsonabfabf82009-07-23 19:02:18 -04001072 op = &args->ops[resp->opcnt++];
1073 op->status = nfserr_retry_uncached_rep;
1074 nfsd4_encode_operation(resp, op);
Andy Adamson074fe892009-04-03 08:28:15 +03001075 }
Andy Adamsonabfabf82009-07-23 19:02:18 -04001076 return op->status;
Andy Adamson074fe892009-04-03 08:28:15 +03001077}
1078
1079/*
Andy Adamson557ce262009-08-28 08:45:04 -04001080 * The sequence operation is not cached because we can use the slot and
1081 * session values.
Andy Adamson074fe892009-04-03 08:28:15 +03001082 */
1083__be32
Andy Adamsonbf864a32009-04-03 08:28:35 +03001084nfsd4_replay_cache_entry(struct nfsd4_compoundres *resp,
1085 struct nfsd4_sequence *seq)
Andy Adamson074fe892009-04-03 08:28:15 +03001086{
Andy Adamson557ce262009-08-28 08:45:04 -04001087 struct nfsd4_slot *slot = resp->cstate.slot;
Andy Adamson074fe892009-04-03 08:28:15 +03001088 __be32 status;
1089
Andy Adamson557ce262009-08-28 08:45:04 -04001090 dprintk("--> %s slot %p\n", __func__, slot);
Andy Adamson074fe892009-04-03 08:28:15 +03001091
Andy Adamsonabfabf82009-07-23 19:02:18 -04001092 /* Either returns 0 or nfserr_retry_uncached */
1093 status = nfsd4_enc_sequence_replay(resp->rqstp->rq_argp, resp);
1094 if (status == nfserr_retry_uncached_rep)
1095 return status;
Andy Adamson074fe892009-04-03 08:28:15 +03001096
Andy Adamson557ce262009-08-28 08:45:04 -04001097 /* The sequence operation has been encoded, cstate->datap set. */
1098 memcpy(resp->cstate.datap, slot->sl_data, slot->sl_datalen);
Andy Adamson074fe892009-04-03 08:28:15 +03001099
Andy Adamson557ce262009-08-28 08:45:04 -04001100 resp->opcnt = slot->sl_opcnt;
1101 resp->p = resp->cstate.datap + XDR_QUADLEN(slot->sl_datalen);
1102 status = slot->sl_status;
Andy Adamson074fe892009-04-03 08:28:15 +03001103
1104 return status;
1105}
1106
Andy Adamson0733d212009-04-03 08:28:01 +03001107/*
1108 * Set the exchange_id flags returned by the server.
1109 */
1110static void
1111nfsd4_set_ex_flags(struct nfs4_client *new, struct nfsd4_exchange_id *clid)
1112{
1113 /* pNFS is not supported */
1114 new->cl_exchange_flags |= EXCHGID4_FLAG_USE_NON_PNFS;
1115
1116 /* Referrals are supported, Migration is not. */
1117 new->cl_exchange_flags |= EXCHGID4_FLAG_SUPP_MOVED_REFER;
1118
1119 /* set the wire flags to return to client. */
1120 clid->flags = new->cl_exchange_flags;
1121}
1122
Al Virob37ad282006-10-19 23:28:59 -07001123__be32
Andy Adamson069b6ad2009-04-03 08:27:58 +03001124nfsd4_exchange_id(struct svc_rqst *rqstp,
1125 struct nfsd4_compound_state *cstate,
1126 struct nfsd4_exchange_id *exid)
1127{
Andy Adamson0733d212009-04-03 08:28:01 +03001128 struct nfs4_client *unconf, *conf, *new;
1129 int status;
1130 unsigned int strhashval;
1131 char dname[HEXDIR_LEN];
Jeff Layton363168b2009-08-14 12:57:56 -04001132 char addr_str[INET6_ADDRSTRLEN];
Andy Adamson0733d212009-04-03 08:28:01 +03001133 nfs4_verifier verf = exid->verifier;
Jeff Layton363168b2009-08-14 12:57:56 -04001134 struct sockaddr *sa = svc_addr(rqstp);
Andy Adamson0733d212009-04-03 08:28:01 +03001135
Jeff Layton363168b2009-08-14 12:57:56 -04001136 rpc_ntop(sa, addr_str, sizeof(addr_str));
Andy Adamson0733d212009-04-03 08:28:01 +03001137 dprintk("%s rqstp=%p exid=%p clname.len=%u clname.data=%p "
Jeff Layton363168b2009-08-14 12:57:56 -04001138 "ip_addr=%s flags %x, spa_how %d\n",
Andy Adamson0733d212009-04-03 08:28:01 +03001139 __func__, rqstp, exid, exid->clname.len, exid->clname.data,
Jeff Layton363168b2009-08-14 12:57:56 -04001140 addr_str, exid->flags, exid->spa_how);
Andy Adamson0733d212009-04-03 08:28:01 +03001141
1142 if (!check_name(exid->clname) || (exid->flags & ~EXCHGID4_FLAG_MASK_A))
1143 return nfserr_inval;
1144
1145 /* Currently only support SP4_NONE */
1146 switch (exid->spa_how) {
1147 case SP4_NONE:
1148 break;
1149 case SP4_SSV:
1150 return nfserr_encr_alg_unsupp;
1151 default:
1152 BUG(); /* checked by xdr code */
1153 case SP4_MACH_CRED:
1154 return nfserr_serverfault; /* no excuse :-/ */
1155 }
1156
1157 status = nfs4_make_rec_clidname(dname, &exid->clname);
1158
1159 if (status)
1160 goto error;
1161
1162 strhashval = clientstr_hashval(dname);
1163
1164 nfs4_lock_state();
1165 status = nfs_ok;
1166
Andy Adamsona1bcecd2009-04-03 08:28:05 +03001167 conf = find_confirmed_client_by_str(dname, strhashval, true);
Andy Adamson0733d212009-04-03 08:28:01 +03001168 if (conf) {
1169 if (!same_verf(&verf, &conf->cl_verifier)) {
1170 /* 18.35.4 case 8 */
1171 if (exid->flags & EXCHGID4_FLAG_UPD_CONFIRMED_REC_A) {
1172 status = nfserr_not_same;
1173 goto out;
1174 }
1175 /* Client reboot: destroy old state */
1176 expire_client(conf);
1177 goto out_new;
1178 }
1179 if (!same_creds(&conf->cl_cred, &rqstp->rq_cred)) {
1180 /* 18.35.4 case 9 */
1181 if (exid->flags & EXCHGID4_FLAG_UPD_CONFIRMED_REC_A) {
1182 status = nfserr_perm;
1183 goto out;
1184 }
1185 expire_client(conf);
1186 goto out_new;
1187 }
Andy Adamson0733d212009-04-03 08:28:01 +03001188 /*
1189 * Set bit when the owner id and verifier map to an already
1190 * confirmed client id (18.35.3).
1191 */
1192 exid->flags |= EXCHGID4_FLAG_CONFIRMED_R;
1193
1194 /*
1195 * Falling into 18.35.4 case 2, possible router replay.
1196 * Leave confirmed record intact and return same result.
1197 */
1198 copy_verf(conf, &verf);
1199 new = conf;
1200 goto out_copy;
Mike Sager6ddbbbf2009-06-16 04:20:47 +03001201 }
1202
1203 /* 18.35.4 case 7 */
1204 if (exid->flags & EXCHGID4_FLAG_UPD_CONFIRMED_REC_A) {
1205 status = nfserr_noent;
1206 goto out;
Andy Adamson0733d212009-04-03 08:28:01 +03001207 }
1208
Andy Adamsona1bcecd2009-04-03 08:28:05 +03001209 unconf = find_unconfirmed_client_by_str(dname, strhashval, true);
Andy Adamson0733d212009-04-03 08:28:01 +03001210 if (unconf) {
1211 /*
1212 * Possible retry or client restart. Per 18.35.4 case 4,
1213 * a new unconfirmed record should be generated regardless
1214 * of whether any properties have changed.
1215 */
1216 expire_client(unconf);
1217 }
1218
1219out_new:
1220 /* Normal case */
Ricardo Labiagab09333c2009-09-10 12:27:34 +03001221 new = create_client(exid->clname, dname, rqstp, &verf);
Andy Adamson0733d212009-04-03 08:28:01 +03001222 if (new == NULL) {
Andy Adamsonbdac86e2009-08-28 08:45:03 -04001223 status = nfserr_serverfault;
Andy Adamson0733d212009-04-03 08:28:01 +03001224 goto out;
1225 }
1226
Andy Adamson0733d212009-04-03 08:28:01 +03001227 gen_clid(new);
Andy Adamson0733d212009-04-03 08:28:01 +03001228 add_to_unconfirmed(new, strhashval);
1229out_copy:
1230 exid->clientid.cl_boot = new->cl_clientid.cl_boot;
1231 exid->clientid.cl_id = new->cl_clientid.cl_id;
1232
Andy Adamson38eb76a2009-04-03 08:28:32 +03001233 exid->seqid = 1;
Andy Adamson0733d212009-04-03 08:28:01 +03001234 nfsd4_set_ex_flags(new, exid);
1235
1236 dprintk("nfsd4_exchange_id seqid %d flags %x\n",
Andy Adamson49557cc2009-07-23 19:02:16 -04001237 new->cl_cs_slot.sl_seqid, new->cl_exchange_flags);
Andy Adamson0733d212009-04-03 08:28:01 +03001238 status = nfs_ok;
1239
1240out:
1241 nfs4_unlock_state();
1242error:
1243 dprintk("nfsd4_exchange_id returns %d\n", ntohl(status));
1244 return status;
Andy Adamson069b6ad2009-04-03 08:27:58 +03001245}
1246
Benny Halevyb85d4c02009-04-03 08:28:08 +03001247static int
Andy Adamson88e588d2009-07-23 19:02:15 -04001248check_slot_seqid(u32 seqid, u32 slot_seqid, int slot_inuse)
Benny Halevyb85d4c02009-04-03 08:28:08 +03001249{
Andy Adamson88e588d2009-07-23 19:02:15 -04001250 dprintk("%s enter. seqid %d slot_seqid %d\n", __func__, seqid,
1251 slot_seqid);
Benny Halevyb85d4c02009-04-03 08:28:08 +03001252
1253 /* The slot is in use, and no response has been sent. */
Andy Adamson88e588d2009-07-23 19:02:15 -04001254 if (slot_inuse) {
1255 if (seqid == slot_seqid)
Benny Halevyb85d4c02009-04-03 08:28:08 +03001256 return nfserr_jukebox;
1257 else
1258 return nfserr_seq_misordered;
1259 }
1260 /* Normal */
Andy Adamson88e588d2009-07-23 19:02:15 -04001261 if (likely(seqid == slot_seqid + 1))
Benny Halevyb85d4c02009-04-03 08:28:08 +03001262 return nfs_ok;
1263 /* Replay */
Andy Adamson88e588d2009-07-23 19:02:15 -04001264 if (seqid == slot_seqid)
Benny Halevyb85d4c02009-04-03 08:28:08 +03001265 return nfserr_replay_cache;
1266 /* Wraparound */
Andy Adamson88e588d2009-07-23 19:02:15 -04001267 if (seqid == 1 && (slot_seqid + 1) == 0)
Benny Halevyb85d4c02009-04-03 08:28:08 +03001268 return nfs_ok;
1269 /* Misordered replay or misordered new request */
1270 return nfserr_seq_misordered;
1271}
1272
Andy Adamson49557cc2009-07-23 19:02:16 -04001273/*
1274 * Cache the create session result into the create session single DRC
1275 * slot cache by saving the xdr structure. sl_seqid has been set.
1276 * Do this for solo or embedded create session operations.
1277 */
1278static void
1279nfsd4_cache_create_session(struct nfsd4_create_session *cr_ses,
1280 struct nfsd4_clid_slot *slot, int nfserr)
1281{
1282 slot->sl_status = nfserr;
1283 memcpy(&slot->sl_cr_ses, cr_ses, sizeof(*cr_ses));
1284}
1285
1286static __be32
1287nfsd4_replay_create_session(struct nfsd4_create_session *cr_ses,
1288 struct nfsd4_clid_slot *slot)
1289{
1290 memcpy(cr_ses, &slot->sl_cr_ses, sizeof(*cr_ses));
1291 return slot->sl_status;
1292}
1293
Andy Adamson069b6ad2009-04-03 08:27:58 +03001294__be32
1295nfsd4_create_session(struct svc_rqst *rqstp,
1296 struct nfsd4_compound_state *cstate,
1297 struct nfsd4_create_session *cr_ses)
1298{
Jeff Layton363168b2009-08-14 12:57:56 -04001299 struct sockaddr *sa = svc_addr(rqstp);
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001300 struct nfs4_client *conf, *unconf;
Andy Adamson49557cc2009-07-23 19:02:16 -04001301 struct nfsd4_clid_slot *cs_slot = NULL;
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001302 int status = 0;
1303
1304 nfs4_lock_state();
1305 unconf = find_unconfirmed_client(&cr_ses->clientid);
1306 conf = find_confirmed_client(&cr_ses->clientid);
1307
1308 if (conf) {
Andy Adamson49557cc2009-07-23 19:02:16 -04001309 cs_slot = &conf->cl_cs_slot;
1310 status = check_slot_seqid(cr_ses->seqid, cs_slot->sl_seqid, 0);
Andy Adamson38eb76a2009-04-03 08:28:32 +03001311 if (status == nfserr_replay_cache) {
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001312 dprintk("Got a create_session replay! seqid= %d\n",
Andy Adamson49557cc2009-07-23 19:02:16 -04001313 cs_slot->sl_seqid);
Andy Adamson38eb76a2009-04-03 08:28:32 +03001314 /* Return the cached reply status */
Andy Adamson49557cc2009-07-23 19:02:16 -04001315 status = nfsd4_replay_create_session(cr_ses, cs_slot);
Andy Adamson38eb76a2009-04-03 08:28:32 +03001316 goto out;
Andy Adamson49557cc2009-07-23 19:02:16 -04001317 } else if (cr_ses->seqid != cs_slot->sl_seqid + 1) {
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001318 status = nfserr_seq_misordered;
1319 dprintk("Sequence misordered!\n");
1320 dprintk("Expected seqid= %d but got seqid= %d\n",
Andy Adamson49557cc2009-07-23 19:02:16 -04001321 cs_slot->sl_seqid, cr_ses->seqid);
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001322 goto out;
1323 }
Andy Adamson49557cc2009-07-23 19:02:16 -04001324 cs_slot->sl_seqid++;
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001325 } else if (unconf) {
1326 if (!same_creds(&unconf->cl_cred, &rqstp->rq_cred) ||
Jeff Layton363168b2009-08-14 12:57:56 -04001327 !rpc_cmp_addr(sa, (struct sockaddr *) &unconf->cl_addr)) {
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001328 status = nfserr_clid_inuse;
1329 goto out;
1330 }
1331
Andy Adamson49557cc2009-07-23 19:02:16 -04001332 cs_slot = &unconf->cl_cs_slot;
1333 status = check_slot_seqid(cr_ses->seqid, cs_slot->sl_seqid, 0);
Andy Adamson38eb76a2009-04-03 08:28:32 +03001334 if (status) {
1335 /* an unconfirmed replay returns misordered */
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001336 status = nfserr_seq_misordered;
Andy Adamson49557cc2009-07-23 19:02:16 -04001337 goto out_cache;
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001338 }
1339
Andy Adamson49557cc2009-07-23 19:02:16 -04001340 cs_slot->sl_seqid++; /* from 0 to 1 */
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001341 move_to_confirmed(unconf);
1342
Andy Adamson38524ab2009-09-10 12:25:59 +03001343 if (cr_ses->flags & SESSION4_BACK_CHAN) {
J. Bruce Fields2bf23872010-03-08 12:37:27 -05001344 unconf->cl_cb_conn.cb_xprt = rqstp->rq_xprt;
1345 svc_xprt_get(rqstp->rq_xprt);
Andy Adamson38524ab2009-09-10 12:25:59 +03001346 rpc_copy_addr(
1347 (struct sockaddr *)&unconf->cl_cb_conn.cb_addr,
1348 sa);
1349 unconf->cl_cb_conn.cb_addrlen = svc_addr_len(sa);
1350 unconf->cl_cb_conn.cb_minorversion =
1351 cstate->minorversion;
1352 unconf->cl_cb_conn.cb_prog = cr_ses->callback_prog;
Ricardo Labiaga2a1d1b52009-09-10 12:26:38 +03001353 unconf->cl_cb_seq_nr = 1;
J. Bruce Fields4b21d0d2010-03-07 23:39:01 -05001354 nfsd4_probe_callback(unconf, &unconf->cl_cb_conn);
Andy Adamson38524ab2009-09-10 12:25:59 +03001355 }
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001356 conf = unconf;
1357 } else {
1358 status = nfserr_stale_clientid;
1359 goto out;
1360 }
1361
J. Bruce Fields408b79b2010-04-15 15:11:09 -04001362 /*
1363 * We do not support RDMA or persistent sessions
1364 */
1365 cr_ses->flags &= ~SESSION4_PERSIST;
1366 cr_ses->flags &= ~SESSION4_RDMA;
1367
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001368 status = alloc_init_session(rqstp, conf, cr_ses);
1369 if (status)
1370 goto out;
1371
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001372 memcpy(cr_ses->sessionid.data, conf->cl_sessionid.data,
1373 NFS4_MAX_SESSIONID_LEN);
Andy Adamson49557cc2009-07-23 19:02:16 -04001374 cr_ses->seqid = cs_slot->sl_seqid;
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001375
Andy Adamson49557cc2009-07-23 19:02:16 -04001376out_cache:
1377 /* cache solo and embedded create sessions under the state lock */
1378 nfsd4_cache_create_session(cr_ses, cs_slot, status);
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001379out:
1380 nfs4_unlock_state();
1381 dprintk("%s returns %d\n", __func__, ntohl(status));
1382 return status;
Andy Adamson069b6ad2009-04-03 08:27:58 +03001383}
1384
J. Bruce Fields57716352010-04-21 12:27:19 -04001385static bool nfsd4_last_compound_op(struct svc_rqst *rqstp)
1386{
1387 struct nfsd4_compoundres *resp = rqstp->rq_resp;
1388 struct nfsd4_compoundargs *argp = rqstp->rq_argp;
1389
1390 return argp->opcnt == resp->opcnt;
1391}
1392
J. Bruce Fields5d4cec22010-05-01 12:56:06 -04001393static bool nfsd4_compound_in_session(struct nfsd4_session *session, struct nfs4_sessionid *sid)
1394{
1395 if (!session)
1396 return 0;
1397 return !memcmp(sid, &session->se_sessionid, sizeof(*sid));
1398}
1399
Andy Adamson069b6ad2009-04-03 08:27:58 +03001400__be32
1401nfsd4_destroy_session(struct svc_rqst *r,
1402 struct nfsd4_compound_state *cstate,
1403 struct nfsd4_destroy_session *sessionid)
1404{
Benny Halevye10e0cf2009-04-03 08:28:38 +03001405 struct nfsd4_session *ses;
1406 u32 status = nfserr_badsession;
1407
1408 /* Notes:
1409 * - The confirmed nfs4_client->cl_sessionid holds destroyed sessinid
1410 * - Should we return nfserr_back_chan_busy if waiting for
1411 * callbacks on to-be-destroyed session?
1412 * - Do we need to clear any callback info from previous session?
1413 */
1414
J. Bruce Fields5d4cec22010-05-01 12:56:06 -04001415 if (nfsd4_compound_in_session(cstate->session, &sessionid->sessionid)) {
J. Bruce Fields57716352010-04-21 12:27:19 -04001416 if (!nfsd4_last_compound_op(r))
1417 return nfserr_not_only_op;
1418 }
Benny Halevye10e0cf2009-04-03 08:28:38 +03001419 dump_sessionid(__func__, &sessionid->sessionid);
Benny Halevy9089f1b2010-05-12 00:12:26 +03001420 spin_lock(&client_lock);
Benny Halevye10e0cf2009-04-03 08:28:38 +03001421 ses = find_in_sessionid_hashtbl(&sessionid->sessionid);
1422 if (!ses) {
Benny Halevy9089f1b2010-05-12 00:12:26 +03001423 spin_unlock(&client_lock);
Benny Halevye10e0cf2009-04-03 08:28:38 +03001424 goto out;
1425 }
1426
1427 unhash_session(ses);
Benny Halevy9089f1b2010-05-12 00:12:26 +03001428 spin_unlock(&client_lock);
Benny Halevye10e0cf2009-04-03 08:28:38 +03001429
Benny Halevyab707e152010-05-12 00:14:06 +03001430 nfs4_lock_state();
Benny Halevye10e0cf2009-04-03 08:28:38 +03001431 /* wait for callbacks */
J. Bruce Fieldsb5a1a812010-03-03 14:52:55 -05001432 nfsd4_set_callback_client(ses->se_client, NULL);
Benny Halevyab707e152010-05-12 00:14:06 +03001433 nfs4_unlock_state();
Benny Halevye10e0cf2009-04-03 08:28:38 +03001434 nfsd4_put_session(ses);
1435 status = nfs_ok;
1436out:
1437 dprintk("%s returns %d\n", __func__, ntohl(status));
1438 return status;
Andy Adamson069b6ad2009-04-03 08:27:58 +03001439}
1440
1441__be32
Benny Halevyb85d4c02009-04-03 08:28:08 +03001442nfsd4_sequence(struct svc_rqst *rqstp,
Andy Adamson069b6ad2009-04-03 08:27:58 +03001443 struct nfsd4_compound_state *cstate,
1444 struct nfsd4_sequence *seq)
1445{
Andy Adamsonf9bb94c2009-04-03 08:28:12 +03001446 struct nfsd4_compoundres *resp = rqstp->rq_resp;
Benny Halevyb85d4c02009-04-03 08:28:08 +03001447 struct nfsd4_session *session;
1448 struct nfsd4_slot *slot;
1449 int status;
1450
Andy Adamsonf9bb94c2009-04-03 08:28:12 +03001451 if (resp->opcnt != 1)
1452 return nfserr_sequence_pos;
1453
Benny Halevy9089f1b2010-05-12 00:12:26 +03001454 spin_lock(&client_lock);
Benny Halevyb85d4c02009-04-03 08:28:08 +03001455 status = nfserr_badsession;
1456 session = find_in_sessionid_hashtbl(&seq->sessionid);
1457 if (!session)
1458 goto out;
1459
1460 status = nfserr_badslot;
Alexandros Batsakis6c18ba92009-06-16 04:19:13 +03001461 if (seq->slotid >= session->se_fchannel.maxreqs)
Benny Halevyb85d4c02009-04-03 08:28:08 +03001462 goto out;
1463
Andy Adamson557ce262009-08-28 08:45:04 -04001464 slot = session->se_slots[seq->slotid];
Benny Halevyb85d4c02009-04-03 08:28:08 +03001465 dprintk("%s: slotid %d\n", __func__, seq->slotid);
1466
Andy Adamsona8dfdae2009-08-28 08:45:02 -04001467 /* We do not negotiate the number of slots yet, so set the
1468 * maxslots to the session maxreqs which is used to encode
1469 * sr_highest_slotid and the sr_target_slot id to maxslots */
1470 seq->maxslots = session->se_fchannel.maxreqs;
1471
Andy Adamson88e588d2009-07-23 19:02:15 -04001472 status = check_slot_seqid(seq->seqid, slot->sl_seqid, slot->sl_inuse);
Benny Halevyb85d4c02009-04-03 08:28:08 +03001473 if (status == nfserr_replay_cache) {
1474 cstate->slot = slot;
1475 cstate->session = session;
Andy Adamsonda3846a2009-04-03 08:28:22 +03001476 /* Return the cached reply status and set cstate->status
Andy Adamson557ce262009-08-28 08:45:04 -04001477 * for nfsd4_proc_compound processing */
Andy Adamsonbf864a32009-04-03 08:28:35 +03001478 status = nfsd4_replay_cache_entry(resp, seq);
Andy Adamsonda3846a2009-04-03 08:28:22 +03001479 cstate->status = nfserr_replay_cache;
Benny Halevyaaf84eb2009-08-20 03:21:56 +03001480 goto out;
Benny Halevyb85d4c02009-04-03 08:28:08 +03001481 }
1482 if (status)
1483 goto out;
1484
1485 /* Success! bump slot seqid */
1486 slot->sl_inuse = true;
1487 slot->sl_seqid = seq->seqid;
Andy Adamson557ce262009-08-28 08:45:04 -04001488 slot->sl_cachethis = seq->cachethis;
Benny Halevyb85d4c02009-04-03 08:28:08 +03001489
1490 cstate->slot = slot;
1491 cstate->session = session;
1492
Benny Halevyb85d4c02009-04-03 08:28:08 +03001493out:
J. Bruce Fields26c0c752010-04-24 15:35:43 -04001494 /* Hold a session reference until done processing the compound. */
Benny Halevyaaf84eb2009-08-20 03:21:56 +03001495 if (cstate->session) {
Benny Halevy36acb662010-05-12 00:13:04 +03001496 nfsd4_get_session(cstate->session);
Benny Halevyd7682982010-05-12 00:13:54 +03001497 atomic_inc(&session->se_client->cl_refcount);
Benny Halevyaaf84eb2009-08-20 03:21:56 +03001498 }
Benny Halevy36acb662010-05-12 00:13:04 +03001499 spin_unlock(&client_lock);
Benny Halevyb85d4c02009-04-03 08:28:08 +03001500 dprintk("%s: return %d\n", __func__, ntohl(status));
1501 return status;
Andy Adamson069b6ad2009-04-03 08:27:58 +03001502}
1503
1504__be32
J. Bruce Fields4dc6ec02010-04-19 15:11:28 -04001505nfsd4_reclaim_complete(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_reclaim_complete *rc)
1506{
1507 if (rc->rca_one_fs) {
1508 if (!cstate->current_fh.fh_dentry)
1509 return nfserr_nofilehandle;
1510 /*
1511 * We don't take advantage of the rca_one_fs case.
1512 * That's OK, it's optional, we can safely ignore it.
1513 */
1514 return nfs_ok;
1515 }
1516 nfs4_lock_state();
1517 if (is_client_expired(cstate->session->se_client)) {
1518 nfs4_unlock_state();
1519 /*
1520 * The following error isn't really legal.
1521 * But we only get here if the client just explicitly
1522 * destroyed the client. Surely it no longer cares what
1523 * error it gets back on an operation for the dead
1524 * client.
1525 */
1526 return nfserr_stale_clientid;
1527 }
1528 nfsd4_create_clid_dir(cstate->session->se_client);
1529 nfs4_unlock_state();
1530 return nfs_ok;
1531}
1532
1533__be32
J.Bruce Fieldsb5914802006-12-13 00:35:38 -08001534nfsd4_setclientid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
1535 struct nfsd4_setclientid *setclid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001536{
Jeff Layton363168b2009-08-14 12:57:56 -04001537 struct sockaddr *sa = svc_addr(rqstp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001538 struct xdr_netobj clname = {
1539 .len = setclid->se_namelen,
1540 .data = setclid->se_name,
1541 };
1542 nfs4_verifier clverifier = setclid->se_verf;
1543 unsigned int strhashval;
NeilBrown28ce6052005-06-23 22:03:56 -07001544 struct nfs4_client *conf, *unconf, *new;
Al Virob37ad282006-10-19 23:28:59 -07001545 __be32 status;
NeilBrowna55370a2005-06-23 22:03:52 -07001546 char dname[HEXDIR_LEN];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001547
Linus Torvalds1da177e2005-04-16 15:20:36 -07001548 if (!check_name(clname))
Neil Brown73aea4e2005-09-13 01:25:39 -07001549 return nfserr_inval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001550
NeilBrowna55370a2005-06-23 22:03:52 -07001551 status = nfs4_make_rec_clidname(dname, &clname);
1552 if (status)
Neil Brown73aea4e2005-09-13 01:25:39 -07001553 return status;
NeilBrowna55370a2005-06-23 22:03:52 -07001554
Linus Torvalds1da177e2005-04-16 15:20:36 -07001555 /*
1556 * XXX The Duplicate Request Cache (DRC) has been checked (??)
1557 * We get here on a DRC miss.
1558 */
1559
NeilBrowna55370a2005-06-23 22:03:52 -07001560 strhashval = clientstr_hashval(dname);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001561
Linus Torvalds1da177e2005-04-16 15:20:36 -07001562 nfs4_lock_state();
Andy Adamsona1bcecd2009-04-03 08:28:05 +03001563 conf = find_confirmed_client_by_str(dname, strhashval, false);
NeilBrown28ce6052005-06-23 22:03:56 -07001564 if (conf) {
J. Bruce Fieldsa186e762007-11-20 16:11:27 -05001565 /* RFC 3530 14.2.33 CASE 0: */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001566 status = nfserr_clid_inuse;
J. Bruce Fields026722c2009-03-18 15:06:26 -04001567 if (!same_creds(&conf->cl_cred, &rqstp->rq_cred)) {
Jeff Layton363168b2009-08-14 12:57:56 -04001568 char addr_str[INET6_ADDRSTRLEN];
1569 rpc_ntop((struct sockaddr *) &conf->cl_addr, addr_str,
1570 sizeof(addr_str));
1571 dprintk("NFSD: setclientid: string in use by client "
1572 "at %s\n", addr_str);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001573 goto out;
1574 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001575 }
J. Bruce Fieldsa186e762007-11-20 16:11:27 -05001576 /*
1577 * section 14.2.33 of RFC 3530 (under the heading "IMPLEMENTATION")
1578 * has a description of SETCLIENTID request processing consisting
1579 * of 5 bullet points, labeled as CASE0 - CASE4 below.
1580 */
Andy Adamsona1bcecd2009-04-03 08:28:05 +03001581 unconf = find_unconfirmed_client_by_str(dname, strhashval, false);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001582 status = nfserr_resource;
1583 if (!conf) {
J. Bruce Fieldsa186e762007-11-20 16:11:27 -05001584 /*
1585 * RFC 3530 14.2.33 CASE 4:
1586 * placed first, because it is the normal case
Linus Torvalds1da177e2005-04-16 15:20:36 -07001587 */
1588 if (unconf)
1589 expire_client(unconf);
Ricardo Labiagab09333c2009-09-10 12:27:34 +03001590 new = create_client(clname, dname, rqstp, &clverifier);
NeilBrowna55370a2005-06-23 22:03:52 -07001591 if (new == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001592 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001593 gen_clid(new);
J. Bruce Fields599e0a22007-07-26 17:04:54 -04001594 } else if (same_verf(&conf->cl_verifier, &clverifier)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001595 /*
J. Bruce Fieldsa186e762007-11-20 16:11:27 -05001596 * RFC 3530 14.2.33 CASE 1:
1597 * probable callback update
Linus Torvalds1da177e2005-04-16 15:20:36 -07001598 */
NeilBrown31f4a6c2005-06-23 22:04:06 -07001599 if (unconf) {
1600 /* Note this is removing unconfirmed {*x***},
1601 * which is stronger than RFC recommended {vxc**}.
1602 * This has the advantage that there is at most
1603 * one {*x***} in either list at any time.
1604 */
1605 expire_client(unconf);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001606 }
Ricardo Labiagab09333c2009-09-10 12:27:34 +03001607 new = create_client(clname, dname, rqstp, &clverifier);
NeilBrowna55370a2005-06-23 22:03:52 -07001608 if (new == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001609 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001610 copy_clid(new, conf);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001611 } else if (!unconf) {
1612 /*
J. Bruce Fieldsa186e762007-11-20 16:11:27 -05001613 * RFC 3530 14.2.33 CASE 2:
1614 * probable client reboot; state will be removed if
1615 * confirmed.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001616 */
Ricardo Labiagab09333c2009-09-10 12:27:34 +03001617 new = create_client(clname, dname, rqstp, &clverifier);
NeilBrowna55370a2005-06-23 22:03:52 -07001618 if (new == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001619 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001620 gen_clid(new);
J. Bruce Fields49ba8782007-11-19 19:09:50 -05001621 } else {
J. Bruce Fieldsa186e762007-11-20 16:11:27 -05001622 /*
1623 * RFC 3530 14.2.33 CASE 3:
1624 * probable client reboot; state will be removed if
1625 * confirmed.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001626 */
1627 expire_client(unconf);
Ricardo Labiagab09333c2009-09-10 12:27:34 +03001628 new = create_client(clname, dname, rqstp, &clverifier);
NeilBrowna55370a2005-06-23 22:03:52 -07001629 if (new == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001630 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001631 gen_clid(new);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001632 }
Jeff Laytonfbf46652009-08-14 12:57:59 -04001633 gen_callback(new, setclid, rpc_get_scope_id(sa));
J. Bruce Fieldsc175b832007-08-09 18:34:32 -04001634 add_to_unconfirmed(new, strhashval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001635 setclid->se_clientid.cl_boot = new->cl_clientid.cl_boot;
1636 setclid->se_clientid.cl_id = new->cl_clientid.cl_id;
1637 memcpy(setclid->se_confirm.data, new->cl_confirm.data, sizeof(setclid->se_confirm.data));
1638 status = nfs_ok;
1639out:
1640 nfs4_unlock_state();
1641 return status;
1642}
1643
1644
1645/*
J. Bruce Fieldsa186e762007-11-20 16:11:27 -05001646 * Section 14.2.34 of RFC 3530 (under the heading "IMPLEMENTATION") has
1647 * a description of SETCLIENTID_CONFIRM request processing consisting of 4
1648 * bullets, labeled as CASE1 - CASE4 below.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001649 */
Al Virob37ad282006-10-19 23:28:59 -07001650__be32
J.Bruce Fieldsb5914802006-12-13 00:35:38 -08001651nfsd4_setclientid_confirm(struct svc_rqst *rqstp,
1652 struct nfsd4_compound_state *cstate,
1653 struct nfsd4_setclientid_confirm *setclientid_confirm)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001654{
Jeff Layton363168b2009-08-14 12:57:56 -04001655 struct sockaddr *sa = svc_addr(rqstp);
NeilBrown21ab45a2005-06-23 22:04:14 -07001656 struct nfs4_client *conf, *unconf;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001657 nfs4_verifier confirm = setclientid_confirm->sc_confirm;
1658 clientid_t * clid = &setclientid_confirm->sc_clientid;
Al Virob37ad282006-10-19 23:28:59 -07001659 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001660
1661 if (STALE_CLIENTID(clid))
1662 return nfserr_stale_clientid;
1663 /*
1664 * XXX The Duplicate Request Cache (DRC) has been checked (??)
1665 * We get here on a DRC miss.
1666 */
1667
1668 nfs4_lock_state();
NeilBrown21ab45a2005-06-23 22:04:14 -07001669
1670 conf = find_confirmed_client(clid);
1671 unconf = find_unconfirmed_client(clid);
1672
1673 status = nfserr_clid_inuse;
Jeff Layton363168b2009-08-14 12:57:56 -04001674 if (conf && !rpc_cmp_addr((struct sockaddr *) &conf->cl_addr, sa))
NeilBrown21ab45a2005-06-23 22:04:14 -07001675 goto out;
Jeff Layton363168b2009-08-14 12:57:56 -04001676 if (unconf && !rpc_cmp_addr((struct sockaddr *) &unconf->cl_addr, sa))
NeilBrown21ab45a2005-06-23 22:04:14 -07001677 goto out;
1678
J. Bruce Fieldsa186e762007-11-20 16:11:27 -05001679 /*
1680 * section 14.2.34 of RFC 3530 has a description of
1681 * SETCLIENTID_CONFIRM request processing consisting
1682 * of 4 bullet points, labeled as CASE1 - CASE4 below.
1683 */
J. Bruce Fields366e0c12007-11-20 15:54:10 -05001684 if (conf && unconf && same_verf(&confirm, &unconf->cl_confirm)) {
J. Bruce Fieldsa186e762007-11-20 16:11:27 -05001685 /*
1686 * RFC 3530 14.2.34 CASE 1:
1687 * callback update
1688 */
J. Bruce Fields599e0a22007-07-26 17:04:54 -04001689 if (!same_creds(&conf->cl_cred, &unconf->cl_cred))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001690 status = nfserr_clid_inuse;
1691 else {
J. Bruce Fields2bf23872010-03-08 12:37:27 -05001692 atomic_set(&conf->cl_cb_set, 0);
J. Bruce Fields4b21d0d2010-03-07 23:39:01 -05001693 nfsd4_probe_callback(conf, &unconf->cl_cb_conn);
NeilBrown1a69c172005-06-23 22:04:08 -07001694 expire_client(unconf);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001695 status = nfs_ok;
NeilBrown1a69c172005-06-23 22:04:08 -07001696
Linus Torvalds1da177e2005-04-16 15:20:36 -07001697 }
J. Bruce Fieldsf3aba4e2007-11-20 16:52:07 -05001698 } else if (conf && !unconf) {
J. Bruce Fieldsa186e762007-11-20 16:11:27 -05001699 /*
1700 * RFC 3530 14.2.34 CASE 2:
1701 * probable retransmitted request; play it safe and
1702 * do nothing.
NeilBrown7c79f732005-06-23 22:04:13 -07001703 */
J. Bruce Fields599e0a22007-07-26 17:04:54 -04001704 if (!same_creds(&conf->cl_cred, &rqstp->rq_cred))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001705 status = nfserr_clid_inuse;
NeilBrown21ab45a2005-06-23 22:04:14 -07001706 else
Linus Torvalds1da177e2005-04-16 15:20:36 -07001707 status = nfs_ok;
NeilBrown7c79f732005-06-23 22:04:13 -07001708 } else if (!conf && unconf
J. Bruce Fields599e0a22007-07-26 17:04:54 -04001709 && same_verf(&unconf->cl_confirm, &confirm)) {
J. Bruce Fieldsa186e762007-11-20 16:11:27 -05001710 /*
1711 * RFC 3530 14.2.34 CASE 3:
1712 * Normal case; new or rebooted client:
NeilBrown7c79f732005-06-23 22:04:13 -07001713 */
J. Bruce Fields599e0a22007-07-26 17:04:54 -04001714 if (!same_creds(&unconf->cl_cred, &rqstp->rq_cred)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001715 status = nfserr_clid_inuse;
1716 } else {
NeilBrown1a69c172005-06-23 22:04:08 -07001717 unsigned int hash =
1718 clientstr_hashval(unconf->cl_recdir);
1719 conf = find_confirmed_client_by_str(unconf->cl_recdir,
Andy Adamsona1bcecd2009-04-03 08:28:05 +03001720 hash, false);
NeilBrown1a69c172005-06-23 22:04:08 -07001721 if (conf) {
NeilBrownc7b9a452005-06-23 22:04:30 -07001722 nfsd4_remove_clid_dir(conf);
NeilBrown1a69c172005-06-23 22:04:08 -07001723 expire_client(conf);
1724 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001725 move_to_confirmed(unconf);
NeilBrown21ab45a2005-06-23 22:04:14 -07001726 conf = unconf;
J. Bruce Fields4b21d0d2010-03-07 23:39:01 -05001727 nfsd4_probe_callback(conf, &conf->cl_cb_conn);
NeilBrown1a69c172005-06-23 22:04:08 -07001728 status = nfs_ok;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001729 }
J. Bruce Fields599e0a22007-07-26 17:04:54 -04001730 } else if ((!conf || (conf && !same_verf(&conf->cl_confirm, &confirm)))
1731 && (!unconf || (unconf && !same_verf(&unconf->cl_confirm,
NeilBrown7c79f732005-06-23 22:04:13 -07001732 &confirm)))) {
J. Bruce Fieldsa186e762007-11-20 16:11:27 -05001733 /*
1734 * RFC 3530 14.2.34 CASE 4:
1735 * Client probably hasn't noticed that we rebooted yet.
NeilBrown7c79f732005-06-23 22:04:13 -07001736 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001737 status = nfserr_stale_clientid;
NeilBrown7c79f732005-06-23 22:04:13 -07001738 } else {
NeilBrown08e89872005-06-23 22:04:11 -07001739 /* check that we have hit one of the cases...*/
1740 status = nfserr_clid_inuse;
1741 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001742out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001743 nfs4_unlock_state();
1744 return status;
1745}
1746
Linus Torvalds1da177e2005-04-16 15:20:36 -07001747/* OPEN Share state helper functions */
1748static inline struct nfs4_file *
1749alloc_init_file(struct inode *ino)
1750{
1751 struct nfs4_file *fp;
1752 unsigned int hashval = file_hashval(ino);
1753
NeilBrowne60d4392005-06-23 22:03:01 -07001754 fp = kmem_cache_alloc(file_slab, GFP_KERNEL);
1755 if (fp) {
J. Bruce Fields8b671b82009-02-22 14:51:34 -08001756 atomic_set(&fp->fi_ref, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001757 INIT_LIST_HEAD(&fp->fi_hash);
NeilBrown8beefa22005-06-23 22:03:08 -07001758 INIT_LIST_HEAD(&fp->fi_stateids);
1759 INIT_LIST_HEAD(&fp->fi_delegations);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001760 fp->fi_inode = igrab(ino);
1761 fp->fi_id = current_fileid++;
Meelap Shah47f99402007-07-17 04:04:40 -07001762 fp->fi_had_conflict = false;
Pavel Emelyanov47cee542010-05-17 20:00:37 +04001763 spin_lock(&recall_lock);
1764 list_add(&fp->fi_hash, &file_hashtbl[hashval]);
1765 spin_unlock(&recall_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001766 return fp;
1767 }
1768 return NULL;
1769}
1770
1771static void
Christoph Lametere18b8902006-12-06 20:33:20 -08001772nfsd4_free_slab(struct kmem_cache **slab)
NeilBrowne60d4392005-06-23 22:03:01 -07001773{
NeilBrowne60d4392005-06-23 22:03:01 -07001774 if (*slab == NULL)
1775 return;
Alexey Dobriyan1a1d92c2006-09-27 01:49:40 -07001776 kmem_cache_destroy(*slab);
NeilBrowne60d4392005-06-23 22:03:01 -07001777 *slab = NULL;
NeilBrowne60d4392005-06-23 22:03:01 -07001778}
1779
J. Bruce Fieldse8ff2a82007-08-01 15:30:59 -04001780void
NeilBrowne60d4392005-06-23 22:03:01 -07001781nfsd4_free_slabs(void)
1782{
1783 nfsd4_free_slab(&stateowner_slab);
1784 nfsd4_free_slab(&file_slab);
NeilBrown5ac049a2005-06-23 22:03:03 -07001785 nfsd4_free_slab(&stateid_slab);
NeilBrown5b2d21c2005-06-23 22:03:04 -07001786 nfsd4_free_slab(&deleg_slab);
NeilBrowne60d4392005-06-23 22:03:01 -07001787}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001788
1789static int
1790nfsd4_init_slabs(void)
1791{
1792 stateowner_slab = kmem_cache_create("nfsd4_stateowners",
Paul Mundt20c2df82007-07-20 10:11:58 +09001793 sizeof(struct nfs4_stateowner), 0, 0, NULL);
NeilBrowne60d4392005-06-23 22:03:01 -07001794 if (stateowner_slab == NULL)
1795 goto out_nomem;
1796 file_slab = kmem_cache_create("nfsd4_files",
Paul Mundt20c2df82007-07-20 10:11:58 +09001797 sizeof(struct nfs4_file), 0, 0, NULL);
NeilBrowne60d4392005-06-23 22:03:01 -07001798 if (file_slab == NULL)
1799 goto out_nomem;
NeilBrown5ac049a2005-06-23 22:03:03 -07001800 stateid_slab = kmem_cache_create("nfsd4_stateids",
Paul Mundt20c2df82007-07-20 10:11:58 +09001801 sizeof(struct nfs4_stateid), 0, 0, NULL);
NeilBrown5ac049a2005-06-23 22:03:03 -07001802 if (stateid_slab == NULL)
1803 goto out_nomem;
NeilBrown5b2d21c2005-06-23 22:03:04 -07001804 deleg_slab = kmem_cache_create("nfsd4_delegations",
Paul Mundt20c2df82007-07-20 10:11:58 +09001805 sizeof(struct nfs4_delegation), 0, 0, NULL);
NeilBrown5b2d21c2005-06-23 22:03:04 -07001806 if (deleg_slab == NULL)
1807 goto out_nomem;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001808 return 0;
NeilBrowne60d4392005-06-23 22:03:01 -07001809out_nomem:
1810 nfsd4_free_slabs();
1811 dprintk("nfsd4: out of memory while initializing nfsv4\n");
1812 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001813}
1814
1815void
1816nfs4_free_stateowner(struct kref *kref)
1817{
1818 struct nfs4_stateowner *sop =
1819 container_of(kref, struct nfs4_stateowner, so_ref);
1820 kfree(sop->so_owner.data);
1821 kmem_cache_free(stateowner_slab, sop);
1822}
1823
1824static inline struct nfs4_stateowner *
1825alloc_stateowner(struct xdr_netobj *owner)
1826{
1827 struct nfs4_stateowner *sop;
1828
1829 if ((sop = kmem_cache_alloc(stateowner_slab, GFP_KERNEL))) {
1830 if ((sop->so_owner.data = kmalloc(owner->len, GFP_KERNEL))) {
1831 memcpy(sop->so_owner.data, owner->data, owner->len);
1832 sop->so_owner.len = owner->len;
1833 kref_init(&sop->so_ref);
1834 return sop;
1835 }
1836 kmem_cache_free(stateowner_slab, sop);
1837 }
1838 return NULL;
1839}
1840
1841static struct nfs4_stateowner *
1842alloc_init_open_stateowner(unsigned int strhashval, struct nfs4_client *clp, struct nfsd4_open *open) {
1843 struct nfs4_stateowner *sop;
1844 struct nfs4_replay *rp;
1845 unsigned int idhashval;
1846
1847 if (!(sop = alloc_stateowner(&open->op_owner)))
1848 return NULL;
1849 idhashval = ownerid_hashval(current_ownerid);
1850 INIT_LIST_HEAD(&sop->so_idhash);
1851 INIT_LIST_HEAD(&sop->so_strhash);
1852 INIT_LIST_HEAD(&sop->so_perclient);
NeilBrownea1da632005-06-23 22:04:17 -07001853 INIT_LIST_HEAD(&sop->so_stateids);
1854 INIT_LIST_HEAD(&sop->so_perstateid); /* not used */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001855 INIT_LIST_HEAD(&sop->so_close_lru);
1856 sop->so_time = 0;
1857 list_add(&sop->so_idhash, &ownerid_hashtbl[idhashval]);
1858 list_add(&sop->so_strhash, &ownerstr_hashtbl[strhashval]);
NeilBrownea1da632005-06-23 22:04:17 -07001859 list_add(&sop->so_perclient, &clp->cl_openowners);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001860 sop->so_is_open_owner = 1;
1861 sop->so_id = current_ownerid++;
1862 sop->so_client = clp;
1863 sop->so_seqid = open->op_seqid;
1864 sop->so_confirmed = 0;
1865 rp = &sop->so_replay;
Al Virode1ae282006-01-18 17:43:47 -08001866 rp->rp_status = nfserr_serverfault;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001867 rp->rp_buflen = 0;
1868 rp->rp_buf = rp->rp_ibuf;
1869 return sop;
1870}
1871
Linus Torvalds1da177e2005-04-16 15:20:36 -07001872static inline void
1873init_stateid(struct nfs4_stateid *stp, struct nfs4_file *fp, struct nfsd4_open *open) {
1874 struct nfs4_stateowner *sop = open->op_stateowner;
1875 unsigned int hashval = stateid_hashval(sop->so_id, fp->fi_id);
1876
1877 INIT_LIST_HEAD(&stp->st_hash);
NeilBrownea1da632005-06-23 22:04:17 -07001878 INIT_LIST_HEAD(&stp->st_perstateowner);
1879 INIT_LIST_HEAD(&stp->st_lockowners);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001880 INIT_LIST_HEAD(&stp->st_perfile);
1881 list_add(&stp->st_hash, &stateid_hashtbl[hashval]);
NeilBrownea1da632005-06-23 22:04:17 -07001882 list_add(&stp->st_perstateowner, &sop->so_stateids);
NeilBrown8beefa22005-06-23 22:03:08 -07001883 list_add(&stp->st_perfile, &fp->fi_stateids);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001884 stp->st_stateowner = sop;
NeilBrown13cd2182005-06-23 22:03:10 -07001885 get_nfs4_file(fp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001886 stp->st_file = fp;
J. Bruce Fieldse4e83ea2010-04-22 16:21:39 -04001887 stp->st_stateid.si_boot = boot_time;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001888 stp->st_stateid.si_stateownerid = sop->so_id;
1889 stp->st_stateid.si_fileid = fp->fi_id;
1890 stp->st_stateid.si_generation = 0;
1891 stp->st_access_bmap = 0;
1892 stp->st_deny_bmap = 0;
Andy Adamson84459a12009-04-03 08:28:56 +03001893 __set_bit(open->op_share_access & ~NFS4_SHARE_WANT_MASK,
1894 &stp->st_access_bmap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001895 __set_bit(open->op_share_deny, &stp->st_deny_bmap);
NeilBrown4c4cd222005-07-07 17:59:27 -07001896 stp->st_openstp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001897}
1898
1899static void
Linus Torvalds1da177e2005-04-16 15:20:36 -07001900move_to_close_lru(struct nfs4_stateowner *sop)
1901{
1902 dprintk("NFSD: move_to_close_lru nfs4_stateowner %p\n", sop);
1903
NeilBrown358dd552006-04-10 22:55:42 -07001904 list_move_tail(&sop->so_close_lru, &close_lru);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001905 sop->so_time = get_seconds();
1906}
1907
Linus Torvalds1da177e2005-04-16 15:20:36 -07001908static int
J. Bruce Fields599e0a22007-07-26 17:04:54 -04001909same_owner_str(struct nfs4_stateowner *sop, struct xdr_netobj *owner,
1910 clientid_t *clid)
1911{
1912 return (sop->so_owner.len == owner->len) &&
1913 0 == memcmp(sop->so_owner.data, owner->data, owner->len) &&
1914 (sop->so_client->cl_clientid.cl_id == clid->cl_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001915}
1916
1917static struct nfs4_stateowner *
1918find_openstateowner_str(unsigned int hashval, struct nfsd4_open *open)
1919{
1920 struct nfs4_stateowner *so = NULL;
1921
1922 list_for_each_entry(so, &ownerstr_hashtbl[hashval], so_strhash) {
J. Bruce Fields599e0a22007-07-26 17:04:54 -04001923 if (same_owner_str(so, &open->op_owner, &open->op_clientid))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001924 return so;
1925 }
1926 return NULL;
1927}
1928
1929/* search file_hashtbl[] for file */
1930static struct nfs4_file *
1931find_file(struct inode *ino)
1932{
1933 unsigned int hashval = file_hashval(ino);
1934 struct nfs4_file *fp;
1935
J. Bruce Fields8b671b82009-02-22 14:51:34 -08001936 spin_lock(&recall_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001937 list_for_each_entry(fp, &file_hashtbl[hashval], fi_hash) {
NeilBrown13cd2182005-06-23 22:03:10 -07001938 if (fp->fi_inode == ino) {
1939 get_nfs4_file(fp);
J. Bruce Fields8b671b82009-02-22 14:51:34 -08001940 spin_unlock(&recall_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001941 return fp;
NeilBrown13cd2182005-06-23 22:03:10 -07001942 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001943 }
J. Bruce Fields8b671b82009-02-22 14:51:34 -08001944 spin_unlock(&recall_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001945 return NULL;
1946}
1947
Andy Adamsond87a8ad2009-04-03 08:28:53 +03001948static inline int access_valid(u32 x, u32 minorversion)
J. Bruce Fieldsba5a6a12006-06-30 01:56:16 -07001949{
Andy Adamsond87a8ad2009-04-03 08:28:53 +03001950 if ((x & NFS4_SHARE_ACCESS_MASK) < NFS4_SHARE_ACCESS_READ)
J. Bruce Fields8838dc42008-01-14 13:12:19 -05001951 return 0;
Andy Adamsond87a8ad2009-04-03 08:28:53 +03001952 if ((x & NFS4_SHARE_ACCESS_MASK) > NFS4_SHARE_ACCESS_BOTH)
1953 return 0;
1954 x &= ~NFS4_SHARE_ACCESS_MASK;
1955 if (minorversion && x) {
1956 if ((x & NFS4_SHARE_WANT_MASK) > NFS4_SHARE_WANT_CANCEL)
1957 return 0;
1958 if ((x & NFS4_SHARE_WHEN_MASK) > NFS4_SHARE_PUSH_DELEG_WHEN_UNCONTENDED)
1959 return 0;
1960 x &= ~(NFS4_SHARE_WANT_MASK | NFS4_SHARE_WHEN_MASK);
1961 }
1962 if (x)
J. Bruce Fields8838dc42008-01-14 13:12:19 -05001963 return 0;
1964 return 1;
J. Bruce Fieldsba5a6a12006-06-30 01:56:16 -07001965}
1966
J. Bruce Fields8838dc42008-01-14 13:12:19 -05001967static inline int deny_valid(u32 x)
J. Bruce Fieldsba5a6a12006-06-30 01:56:16 -07001968{
J. Bruce Fields8838dc42008-01-14 13:12:19 -05001969 /* Note: unlike access bits, deny bits may be zero. */
1970 return x <= NFS4_SHARE_DENY_BOTH;
J. Bruce Fieldsba5a6a12006-06-30 01:56:16 -07001971}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001972
J. Bruce Fields4f83aa32008-07-07 15:02:02 -04001973/*
1974 * We store the NONE, READ, WRITE, and BOTH bits separately in the
1975 * st_{access,deny}_bmap field of the stateid, in order to track not
1976 * only what share bits are currently in force, but also what
1977 * combinations of share bits previous opens have used. This allows us
1978 * to enforce the recommendation of rfc 3530 14.2.19 that the server
1979 * return an error if the client attempt to downgrade to a combination
1980 * of share bits not explicable by closing some of its previous opens.
1981 *
1982 * XXX: This enforcement is actually incomplete, since we don't keep
1983 * track of access/deny bit combinations; so, e.g., we allow:
1984 *
1985 * OPEN allow read, deny write
1986 * OPEN allow both, deny none
1987 * DOWNGRADE allow read, deny none
1988 *
1989 * which we should reject.
1990 */
NeilBrownfd39ca92005-06-23 22:04:03 -07001991static void
Linus Torvalds1da177e2005-04-16 15:20:36 -07001992set_access(unsigned int *access, unsigned long bmap) {
1993 int i;
1994
1995 *access = 0;
1996 for (i = 1; i < 4; i++) {
1997 if (test_bit(i, &bmap))
1998 *access |= i;
1999 }
2000}
2001
NeilBrownfd39ca92005-06-23 22:04:03 -07002002static void
Linus Torvalds1da177e2005-04-16 15:20:36 -07002003set_deny(unsigned int *deny, unsigned long bmap) {
2004 int i;
2005
2006 *deny = 0;
2007 for (i = 0; i < 4; i++) {
2008 if (test_bit(i, &bmap))
2009 *deny |= i ;
2010 }
2011}
2012
2013static int
2014test_share(struct nfs4_stateid *stp, struct nfsd4_open *open) {
2015 unsigned int access, deny;
2016
2017 set_access(&access, stp->st_access_bmap);
2018 set_deny(&deny, stp->st_deny_bmap);
2019 if ((access & open->op_share_deny) || (deny & open->op_share_access))
2020 return 0;
2021 return 1;
2022}
2023
2024/*
2025 * Called to check deny when READ with all zero stateid or
2026 * WRITE with all zero or all one stateid
2027 */
Al Virob37ad282006-10-19 23:28:59 -07002028static __be32
Linus Torvalds1da177e2005-04-16 15:20:36 -07002029nfs4_share_conflict(struct svc_fh *current_fh, unsigned int deny_type)
2030{
2031 struct inode *ino = current_fh->fh_dentry->d_inode;
2032 struct nfs4_file *fp;
2033 struct nfs4_stateid *stp;
Al Virob37ad282006-10-19 23:28:59 -07002034 __be32 ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002035
2036 dprintk("NFSD: nfs4_share_conflict\n");
2037
2038 fp = find_file(ino);
NeilBrown13cd2182005-06-23 22:03:10 -07002039 if (!fp)
2040 return nfs_ok;
NeilBrownb7009492005-07-07 17:59:23 -07002041 ret = nfserr_locked;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002042 /* Search for conflicting share reservations */
NeilBrown13cd2182005-06-23 22:03:10 -07002043 list_for_each_entry(stp, &fp->fi_stateids, st_perfile) {
2044 if (test_bit(deny_type, &stp->st_deny_bmap) ||
2045 test_bit(NFS4_SHARE_DENY_BOTH, &stp->st_deny_bmap))
2046 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002047 }
NeilBrown13cd2182005-06-23 22:03:10 -07002048 ret = nfs_ok;
2049out:
2050 put_nfs4_file(fp);
2051 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002052}
2053
2054static inline void
2055nfs4_file_downgrade(struct file *filp, unsigned int share_access)
2056{
2057 if (share_access & NFS4_SHARE_ACCESS_WRITE) {
Dave Hansenaceaf782008-02-15 14:37:31 -08002058 drop_file_write_access(filp);
Wu Fengguang42e49602010-03-05 13:42:01 -08002059 spin_lock(&filp->f_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002060 filp->f_mode = (filp->f_mode | FMODE_READ) & ~FMODE_WRITE;
Wu Fengguang42e49602010-03-05 13:42:01 -08002061 spin_unlock(&filp->f_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002062 }
2063}
2064
2065/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002066 * Spawn a thread to perform a recall on the delegation represented
2067 * by the lease (file_lock)
2068 *
2069 * Called from break_lease() with lock_kernel() held.
2070 * Note: we assume break_lease will only call this *once* for any given
2071 * lease.
2072 */
2073static
2074void nfsd_break_deleg_cb(struct file_lock *fl)
2075{
J. Bruce Fields63e48632009-05-01 22:36:55 -04002076 struct nfs4_delegation *dp = (struct nfs4_delegation *)fl->fl_owner;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002077
2078 dprintk("NFSD nfsd_break_deleg_cb: dp %p fl %p\n",dp,fl);
2079 if (!dp)
2080 return;
2081
2082 /* We're assuming the state code never drops its reference
2083 * without first removing the lease. Since we're in this lease
2084 * callback (and since the lease code is serialized by the kernel
2085 * lock) we know the server hasn't removed the lease yet, we know
2086 * it's safe to take a reference: */
2087 atomic_inc(&dp->dl_count);
2088
2089 spin_lock(&recall_lock);
2090 list_add_tail(&dp->dl_recall_lru, &del_recall_lru);
2091 spin_unlock(&recall_lock);
2092
2093 /* only place dl_time is set. protected by lock_kernel*/
2094 dp->dl_time = get_seconds();
2095
J. Bruce Fields0272e1f2007-09-12 18:56:12 -04002096 /*
2097 * We don't want the locks code to timeout the lease for us;
2098 * we'll remove it ourself if the delegation isn't returned
2099 * in time.
2100 */
2101 fl->fl_break_time = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002102
J. Bruce Fields63e48632009-05-01 22:36:55 -04002103 dp->dl_file->fi_had_conflict = true;
2104 nfsd4_cb_recall(dp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002105}
2106
2107/*
2108 * The file_lock is being reapd.
2109 *
2110 * Called by locks_free_lock() with lock_kernel() held.
2111 */
2112static
2113void nfsd_release_deleg_cb(struct file_lock *fl)
2114{
2115 struct nfs4_delegation *dp = (struct nfs4_delegation *)fl->fl_owner;
2116
2117 dprintk("NFSD nfsd_release_deleg_cb: fl %p dp %p dl_count %d\n", fl,dp, atomic_read(&dp->dl_count));
2118
2119 if (!(fl->fl_flags & FL_LEASE) || !dp)
2120 return;
2121 dp->dl_flock = NULL;
2122}
2123
2124/*
2125 * Set the delegation file_lock back pointer.
2126 *
J. Bruce Fieldsa9933ce2007-06-07 17:09:49 -04002127 * Called from setlease() with lock_kernel() held.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002128 */
2129static
2130void nfsd_copy_lock_deleg_cb(struct file_lock *new, struct file_lock *fl)
2131{
2132 struct nfs4_delegation *dp = (struct nfs4_delegation *)new->fl_owner;
2133
2134 dprintk("NFSD: nfsd_copy_lock_deleg_cb: new fl %p dp %p\n", new, dp);
2135 if (!dp)
2136 return;
2137 dp->dl_flock = new;
2138}
2139
2140/*
J. Bruce Fieldsa9933ce2007-06-07 17:09:49 -04002141 * Called from setlease() with lock_kernel() held
Linus Torvalds1da177e2005-04-16 15:20:36 -07002142 */
2143static
2144int nfsd_same_client_deleg_cb(struct file_lock *onlist, struct file_lock *try)
2145{
2146 struct nfs4_delegation *onlistd =
2147 (struct nfs4_delegation *)onlist->fl_owner;
2148 struct nfs4_delegation *tryd =
2149 (struct nfs4_delegation *)try->fl_owner;
2150
2151 if (onlist->fl_lmops != try->fl_lmops)
2152 return 0;
2153
2154 return onlistd->dl_client == tryd->dl_client;
2155}
2156
2157
2158static
2159int nfsd_change_deleg_cb(struct file_lock **onlist, int arg)
2160{
2161 if (arg & F_UNLCK)
2162 return lease_modify(onlist, arg);
2163 else
2164 return -EAGAIN;
2165}
2166
Alexey Dobriyan7b021962009-09-21 17:01:12 -07002167static const struct lock_manager_operations nfsd_lease_mng_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002168 .fl_break = nfsd_break_deleg_cb,
2169 .fl_release_private = nfsd_release_deleg_cb,
2170 .fl_copy_lock = nfsd_copy_lock_deleg_cb,
2171 .fl_mylease = nfsd_same_client_deleg_cb,
2172 .fl_change = nfsd_change_deleg_cb,
2173};
2174
2175
Al Virob37ad282006-10-19 23:28:59 -07002176__be32
Andy Adamson66689582009-04-03 08:28:45 +03002177nfsd4_process_open1(struct nfsd4_compound_state *cstate,
2178 struct nfsd4_open *open)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002179{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002180 clientid_t *clientid = &open->op_clientid;
2181 struct nfs4_client *clp = NULL;
2182 unsigned int strhashval;
2183 struct nfs4_stateowner *sop = NULL;
2184
Linus Torvalds1da177e2005-04-16 15:20:36 -07002185 if (!check_name(open->op_owner))
J. Bruce Fields0f442aa2006-01-18 17:43:34 -08002186 return nfserr_inval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002187
2188 if (STALE_CLIENTID(&open->op_clientid))
2189 return nfserr_stale_clientid;
2190
2191 strhashval = ownerstr_hashval(clientid->cl_id, open->op_owner);
2192 sop = find_openstateowner_str(strhashval, open);
J. Bruce Fields0f442aa2006-01-18 17:43:34 -08002193 open->op_stateowner = sop;
2194 if (!sop) {
2195 /* Make sure the client's lease hasn't expired. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002196 clp = find_confirmed_client(clientid);
2197 if (clp == NULL)
J. Bruce Fields0f442aa2006-01-18 17:43:34 -08002198 return nfserr_expired;
2199 goto renew;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002200 }
Andy Adamson66689582009-04-03 08:28:45 +03002201 /* When sessions are used, skip open sequenceid processing */
2202 if (nfsd4_has_session(cstate))
2203 goto renew;
J. Bruce Fields0f442aa2006-01-18 17:43:34 -08002204 if (!sop->so_confirmed) {
2205 /* Replace unconfirmed owners without checking for replay. */
2206 clp = sop->so_client;
J. Bruce Fieldsf044ff82009-01-11 15:24:04 -05002207 release_openowner(sop);
J. Bruce Fields0f442aa2006-01-18 17:43:34 -08002208 open->op_stateowner = NULL;
2209 goto renew;
2210 }
2211 if (open->op_seqid == sop->so_seqid - 1) {
2212 if (sop->so_replay.rp_buflen)
Al Viroa90b0612006-10-19 23:29:03 -07002213 return nfserr_replay_me;
J. Bruce Fields0f442aa2006-01-18 17:43:34 -08002214 /* The original OPEN failed so spectacularly
2215 * that we don't even have replay data saved!
2216 * Therefore, we have no choice but to continue
2217 * processing this OPEN; presumably, we'll
2218 * fail again for the same reason.
2219 */
2220 dprintk("nfsd4_process_open1: replay with no replay cache\n");
2221 goto renew;
2222 }
2223 if (open->op_seqid != sop->so_seqid)
2224 return nfserr_bad_seqid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002225renew:
J. Bruce Fields0f442aa2006-01-18 17:43:34 -08002226 if (open->op_stateowner == NULL) {
2227 sop = alloc_init_open_stateowner(strhashval, clp, open);
2228 if (sop == NULL)
2229 return nfserr_resource;
2230 open->op_stateowner = sop;
2231 }
2232 list_del_init(&sop->so_close_lru);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002233 renew_client(sop->so_client);
J. Bruce Fields0f442aa2006-01-18 17:43:34 -08002234 return nfs_ok;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002235}
2236
Al Virob37ad282006-10-19 23:28:59 -07002237static inline __be32
NeilBrown4a6e43e2005-06-23 22:02:50 -07002238nfs4_check_delegmode(struct nfs4_delegation *dp, int flags)
2239{
2240 if ((flags & WR_STATE) && (dp->dl_type == NFS4_OPEN_DELEGATE_READ))
2241 return nfserr_openmode;
2242 else
2243 return nfs_ok;
2244}
2245
NeilBrown52f4fb42005-06-23 22:02:49 -07002246static struct nfs4_delegation *
2247find_delegation_file(struct nfs4_file *fp, stateid_t *stid)
2248{
2249 struct nfs4_delegation *dp;
2250
NeilBrownea1da632005-06-23 22:04:17 -07002251 list_for_each_entry(dp, &fp->fi_delegations, dl_perfile) {
NeilBrown52f4fb42005-06-23 22:02:49 -07002252 if (dp->dl_stateid.si_stateownerid == stid->si_stateownerid)
2253 return dp;
2254 }
2255 return NULL;
2256}
2257
Al Virob37ad282006-10-19 23:28:59 -07002258static __be32
NeilBrown567d9822005-06-23 22:02:53 -07002259nfs4_check_deleg(struct nfs4_file *fp, struct nfsd4_open *open,
2260 struct nfs4_delegation **dp)
2261{
2262 int flags;
Al Virob37ad282006-10-19 23:28:59 -07002263 __be32 status = nfserr_bad_stateid;
NeilBrown567d9822005-06-23 22:02:53 -07002264
2265 *dp = find_delegation_file(fp, &open->op_delegate_stateid);
2266 if (*dp == NULL)
NeilBrownc44c5ee2005-06-23 22:02:54 -07002267 goto out;
NeilBrown567d9822005-06-23 22:02:53 -07002268 flags = open->op_share_access == NFS4_SHARE_ACCESS_READ ?
2269 RD_STATE : WR_STATE;
2270 status = nfs4_check_delegmode(*dp, flags);
2271 if (status)
2272 *dp = NULL;
NeilBrownc44c5ee2005-06-23 22:02:54 -07002273out:
2274 if (open->op_claim_type != NFS4_OPEN_CLAIM_DELEGATE_CUR)
2275 return nfs_ok;
2276 if (status)
2277 return status;
2278 open->op_stateowner->so_confirmed = 1;
2279 return nfs_ok;
NeilBrown567d9822005-06-23 22:02:53 -07002280}
2281
Al Virob37ad282006-10-19 23:28:59 -07002282static __be32
Linus Torvalds1da177e2005-04-16 15:20:36 -07002283nfs4_check_open(struct nfs4_file *fp, struct nfsd4_open *open, struct nfs4_stateid **stpp)
2284{
2285 struct nfs4_stateid *local;
Al Virob37ad282006-10-19 23:28:59 -07002286 __be32 status = nfserr_share_denied;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002287 struct nfs4_stateowner *sop = open->op_stateowner;
2288
NeilBrown8beefa22005-06-23 22:03:08 -07002289 list_for_each_entry(local, &fp->fi_stateids, st_perfile) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002290 /* ignore lock owners */
2291 if (local->st_stateowner->so_is_open_owner == 0)
2292 continue;
2293 /* remember if we have seen this open owner */
2294 if (local->st_stateowner == sop)
2295 *stpp = local;
2296 /* check for conflicting share reservations */
2297 if (!test_share(local, open))
2298 goto out;
2299 }
2300 status = 0;
2301out:
2302 return status;
2303}
2304
NeilBrown5ac049a2005-06-23 22:03:03 -07002305static inline struct nfs4_stateid *
2306nfs4_alloc_stateid(void)
2307{
2308 return kmem_cache_alloc(stateid_slab, GFP_KERNEL);
2309}
2310
Al Virob37ad282006-10-19 23:28:59 -07002311static __be32
Linus Torvalds1da177e2005-04-16 15:20:36 -07002312nfs4_new_open(struct svc_rqst *rqstp, struct nfs4_stateid **stpp,
NeilBrown567d9822005-06-23 22:02:53 -07002313 struct nfs4_delegation *dp,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002314 struct svc_fh *cur_fh, int flags)
2315{
2316 struct nfs4_stateid *stp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002317
NeilBrown5ac049a2005-06-23 22:03:03 -07002318 stp = nfs4_alloc_stateid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002319 if (stp == NULL)
2320 return nfserr_resource;
2321
NeilBrown567d9822005-06-23 22:02:53 -07002322 if (dp) {
2323 get_file(dp->dl_vfs_file);
2324 stp->st_vfs_file = dp->dl_vfs_file;
2325 } else {
Al Virob37ad282006-10-19 23:28:59 -07002326 __be32 status;
NeilBrown567d9822005-06-23 22:02:53 -07002327 status = nfsd_open(rqstp, cur_fh, S_IFREG, flags,
2328 &stp->st_vfs_file);
2329 if (status) {
2330 if (status == nfserr_dropit)
2331 status = nfserr_jukebox;
NeilBrown5ac049a2005-06-23 22:03:03 -07002332 kmem_cache_free(stateid_slab, stp);
NeilBrown567d9822005-06-23 22:02:53 -07002333 return status;
2334 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002335 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002336 *stpp = stp;
2337 return 0;
2338}
2339
Al Virob37ad282006-10-19 23:28:59 -07002340static inline __be32
Linus Torvalds1da177e2005-04-16 15:20:36 -07002341nfsd4_truncate(struct svc_rqst *rqstp, struct svc_fh *fh,
2342 struct nfsd4_open *open)
2343{
2344 struct iattr iattr = {
2345 .ia_valid = ATTR_SIZE,
2346 .ia_size = 0,
2347 };
2348 if (!open->op_truncate)
2349 return 0;
2350 if (!(open->op_share_access & NFS4_SHARE_ACCESS_WRITE))
Al Viro92465852006-01-18 17:43:46 -08002351 return nfserr_inval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002352 return nfsd_setattr(rqstp, fh, &iattr, 0, (time_t)0);
2353}
2354
Al Virob37ad282006-10-19 23:28:59 -07002355static __be32
Linus Torvalds1da177e2005-04-16 15:20:36 -07002356nfs4_upgrade_open(struct svc_rqst *rqstp, struct svc_fh *cur_fh, struct nfs4_stateid *stp, struct nfsd4_open *open)
2357{
2358 struct file *filp = stp->st_vfs_file;
Josef "Jeff" Sipek7eaa36e2006-12-08 02:36:41 -08002359 struct inode *inode = filp->f_path.dentry->d_inode;
J. Bruce Fields6c26d082006-01-18 17:43:38 -08002360 unsigned int share_access, new_writer;
Al Virob37ad282006-10-19 23:28:59 -07002361 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002362
2363 set_access(&share_access, stp->st_access_bmap);
J. Bruce Fields6c26d082006-01-18 17:43:38 -08002364 new_writer = (~share_access) & open->op_share_access
2365 & NFS4_SHARE_ACCESS_WRITE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002366
J. Bruce Fields6c26d082006-01-18 17:43:38 -08002367 if (new_writer) {
Al Virob37ad282006-10-19 23:28:59 -07002368 int err = get_write_access(inode);
2369 if (err)
2370 return nfserrno(err);
Benny Halevye518f052008-07-04 15:38:41 +03002371 err = mnt_want_write(cur_fh->fh_export->ex_path.mnt);
2372 if (err)
2373 return nfserrno(err);
2374 file_take_write(filp);
J. Bruce Fields6c26d082006-01-18 17:43:38 -08002375 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002376 status = nfsd4_truncate(rqstp, cur_fh, open);
2377 if (status) {
J. Bruce Fields6c26d082006-01-18 17:43:38 -08002378 if (new_writer)
2379 put_write_access(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002380 return status;
2381 }
2382 /* remember the open */
J. Bruce Fields6c26d082006-01-18 17:43:38 -08002383 filp->f_mode |= open->op_share_access;
J. Bruce Fieldsb55e0ba2008-04-28 18:22:50 -04002384 __set_bit(open->op_share_access, &stp->st_access_bmap);
2385 __set_bit(open->op_share_deny, &stp->st_deny_bmap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002386
2387 return nfs_ok;
2388}
2389
2390
Linus Torvalds1da177e2005-04-16 15:20:36 -07002391static void
NeilBrown37515172005-07-07 17:59:16 -07002392nfs4_set_claim_prev(struct nfsd4_open *open)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002393{
NeilBrown37515172005-07-07 17:59:16 -07002394 open->op_stateowner->so_confirmed = 1;
2395 open->op_stateowner->so_client->cl_firststate = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002396}
2397
2398/*
2399 * Attempt to hand out a delegation.
2400 */
2401static void
2402nfs4_open_delegation(struct svc_fh *fh, struct nfsd4_open *open, struct nfs4_stateid *stp)
2403{
2404 struct nfs4_delegation *dp;
2405 struct nfs4_stateowner *sop = stp->st_stateowner;
J. Bruce Fields2bf23872010-03-08 12:37:27 -05002406 int cb_up = atomic_read(&sop->so_client->cl_cb_set);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002407 struct file_lock fl, *flp = &fl;
2408 int status, flag = 0;
2409
2410 flag = NFS4_OPEN_DELEGATE_NONE;
NeilBrown7b190fe2005-06-23 22:03:23 -07002411 open->op_recall = 0;
2412 switch (open->op_claim_type) {
2413 case NFS4_OPEN_CLAIM_PREVIOUS:
J. Bruce Fields2bf23872010-03-08 12:37:27 -05002414 if (!cb_up)
NeilBrown7b190fe2005-06-23 22:03:23 -07002415 open->op_recall = 1;
2416 flag = open->op_delegate_type;
2417 if (flag == NFS4_OPEN_DELEGATE_NONE)
2418 goto out;
2419 break;
2420 case NFS4_OPEN_CLAIM_NULL:
2421 /* Let's not give out any delegations till everyone's
2422 * had the chance to reclaim theirs.... */
J. Bruce Fieldsaf558e32007-09-06 12:34:25 -04002423 if (locks_in_grace())
NeilBrown7b190fe2005-06-23 22:03:23 -07002424 goto out;
J. Bruce Fields2bf23872010-03-08 12:37:27 -05002425 if (!cb_up || !sop->so_confirmed)
NeilBrown7b190fe2005-06-23 22:03:23 -07002426 goto out;
2427 if (open->op_share_access & NFS4_SHARE_ACCESS_WRITE)
2428 flag = NFS4_OPEN_DELEGATE_WRITE;
2429 else
2430 flag = NFS4_OPEN_DELEGATE_READ;
2431 break;
2432 default:
2433 goto out;
2434 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002435
2436 dp = alloc_init_deleg(sop->so_client, stp, fh, flag);
2437 if (dp == NULL) {
2438 flag = NFS4_OPEN_DELEGATE_NONE;
2439 goto out;
2440 }
2441 locks_init_lock(&fl);
2442 fl.fl_lmops = &nfsd_lease_mng_ops;
2443 fl.fl_flags = FL_LEASE;
Felix Blyakher9167f502008-02-26 10:54:36 -08002444 fl.fl_type = flag == NFS4_OPEN_DELEGATE_READ? F_RDLCK: F_WRLCK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002445 fl.fl_end = OFFSET_MAX;
2446 fl.fl_owner = (fl_owner_t)dp;
2447 fl.fl_file = stp->st_vfs_file;
2448 fl.fl_pid = current->tgid;
2449
J. Bruce Fieldsa9933ce2007-06-07 17:09:49 -04002450 /* vfs_setlease checks to see if delegation should be handed out.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002451 * the lock_manager callbacks fl_mylease and fl_change are used
2452 */
Felix Blyakher9167f502008-02-26 10:54:36 -08002453 if ((status = vfs_setlease(stp->st_vfs_file, fl.fl_type, &flp))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002454 dprintk("NFSD: setlease failed [%d], no delegation\n", status);
NeilBrownc9071322005-04-16 15:26:38 -07002455 unhash_delegation(dp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002456 flag = NFS4_OPEN_DELEGATE_NONE;
2457 goto out;
2458 }
2459
2460 memcpy(&open->op_delegate_stateid, &dp->dl_stateid, sizeof(dp->dl_stateid));
2461
Benny Halevy8c10cbd2009-10-19 12:04:53 +02002462 dprintk("NFSD: delegation stateid=" STATEID_FMT "\n",
2463 STATEID_VAL(&dp->dl_stateid));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002464out:
NeilBrown7b190fe2005-06-23 22:03:23 -07002465 if (open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS
2466 && flag == NFS4_OPEN_DELEGATE_NONE
2467 && open->op_delegate_type != NFS4_OPEN_DELEGATE_NONE)
J. Bruce Fields2fdada02007-07-27 16:10:37 -04002468 dprintk("NFSD: WARNING: refusing delegation reclaim\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002469 open->op_delegate_type = flag;
2470}
2471
2472/*
2473 * called with nfs4_lock_state() held.
2474 */
Al Virob37ad282006-10-19 23:28:59 -07002475__be32
Linus Torvalds1da177e2005-04-16 15:20:36 -07002476nfsd4_process_open2(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_open *open)
2477{
Andy Adamson66689582009-04-03 08:28:45 +03002478 struct nfsd4_compoundres *resp = rqstp->rq_resp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002479 struct nfs4_file *fp = NULL;
2480 struct inode *ino = current_fh->fh_dentry->d_inode;
2481 struct nfs4_stateid *stp = NULL;
NeilBrown567d9822005-06-23 22:02:53 -07002482 struct nfs4_delegation *dp = NULL;
Al Virob37ad282006-10-19 23:28:59 -07002483 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002484
2485 status = nfserr_inval;
Andy Adamsond87a8ad2009-04-03 08:28:53 +03002486 if (!access_valid(open->op_share_access, resp->cstate.minorversion)
J. Bruce Fieldsba5a6a12006-06-30 01:56:16 -07002487 || !deny_valid(open->op_share_deny))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002488 goto out;
2489 /*
2490 * Lookup file; if found, lookup stateid and check open request,
2491 * and check for delegations in the process of being recalled.
2492 * If not found, create the nfs4_file struct
2493 */
2494 fp = find_file(ino);
2495 if (fp) {
2496 if ((status = nfs4_check_open(fp, open, &stp)))
2497 goto out;
NeilBrownc44c5ee2005-06-23 22:02:54 -07002498 status = nfs4_check_deleg(fp, open, &dp);
2499 if (status)
2500 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002501 } else {
NeilBrownc44c5ee2005-06-23 22:02:54 -07002502 status = nfserr_bad_stateid;
2503 if (open->op_claim_type == NFS4_OPEN_CLAIM_DELEGATE_CUR)
2504 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002505 status = nfserr_resource;
2506 fp = alloc_init_file(ino);
2507 if (fp == NULL)
2508 goto out;
2509 }
2510
2511 /*
2512 * OPEN the file, or upgrade an existing OPEN.
2513 * If truncate fails, the OPEN fails.
2514 */
2515 if (stp) {
2516 /* Stateid was found, this is an OPEN upgrade */
2517 status = nfs4_upgrade_open(rqstp, current_fh, stp, open);
2518 if (status)
2519 goto out;
NeilBrown444c2c02005-07-07 17:59:22 -07002520 update_stateid(&stp->st_stateid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002521 } else {
2522 /* Stateid was not found, this is a new OPEN */
2523 int flags = 0;
J. Bruce Fields9ecb6a02006-06-30 01:56:17 -07002524 if (open->op_share_access & NFS4_SHARE_ACCESS_READ)
Miklos Szeredi8837abc2008-06-16 13:20:29 +02002525 flags |= NFSD_MAY_READ;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002526 if (open->op_share_access & NFS4_SHARE_ACCESS_WRITE)
Miklos Szeredi8837abc2008-06-16 13:20:29 +02002527 flags |= NFSD_MAY_WRITE;
NeilBrown567d9822005-06-23 22:02:53 -07002528 status = nfs4_new_open(rqstp, &stp, dp, current_fh, flags);
2529 if (status)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002530 goto out;
2531 init_stateid(stp, fp, open);
2532 status = nfsd4_truncate(rqstp, current_fh, open);
2533 if (status) {
J. Bruce Fields22839632009-01-11 14:27:17 -05002534 release_open_stateid(stp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002535 goto out;
2536 }
Andy Adamson66689582009-04-03 08:28:45 +03002537 if (nfsd4_has_session(&resp->cstate))
2538 update_stateid(&stp->st_stateid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002539 }
2540 memcpy(&open->op_stateid, &stp->st_stateid, sizeof(stateid_t));
2541
J. Bruce Fields4dc6ec02010-04-19 15:11:28 -04002542 if (nfsd4_has_session(&resp->cstate))
Andy Adamson66689582009-04-03 08:28:45 +03002543 open->op_stateowner->so_confirmed = 1;
2544
Linus Torvalds1da177e2005-04-16 15:20:36 -07002545 /*
2546 * Attempt to hand out a delegation. No error return, because the
2547 * OPEN succeeds even if we fail.
2548 */
2549 nfs4_open_delegation(current_fh, open, stp);
2550
2551 status = nfs_ok;
2552
Benny Halevy8c10cbd2009-10-19 12:04:53 +02002553 dprintk("%s: stateid=" STATEID_FMT "\n", __func__,
2554 STATEID_VAL(&stp->st_stateid));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002555out:
NeilBrown13cd2182005-06-23 22:03:10 -07002556 if (fp)
2557 put_nfs4_file(fp);
NeilBrown37515172005-07-07 17:59:16 -07002558 if (status == 0 && open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS)
2559 nfs4_set_claim_prev(open);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002560 /*
2561 * To finish the open response, we just need to set the rflags.
2562 */
2563 open->op_rflags = NFS4_OPEN_RESULT_LOCKTYPE_POSIX;
Andy Adamson66689582009-04-03 08:28:45 +03002564 if (!open->op_stateowner->so_confirmed &&
2565 !nfsd4_has_session(&resp->cstate))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002566 open->op_rflags |= NFS4_OPEN_RESULT_CONFIRM;
2567
2568 return status;
2569}
2570
Al Virob37ad282006-10-19 23:28:59 -07002571__be32
J.Bruce Fieldsb5914802006-12-13 00:35:38 -08002572nfsd4_renew(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
2573 clientid_t *clid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002574{
2575 struct nfs4_client *clp;
Al Virob37ad282006-10-19 23:28:59 -07002576 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002577
2578 nfs4_lock_state();
2579 dprintk("process_renew(%08x/%08x): starting\n",
2580 clid->cl_boot, clid->cl_id);
2581 status = nfserr_stale_clientid;
2582 if (STALE_CLIENTID(clid))
2583 goto out;
2584 clp = find_confirmed_client(clid);
2585 status = nfserr_expired;
2586 if (clp == NULL) {
2587 /* We assume the client took too long to RENEW. */
2588 dprintk("nfsd4_renew: clientid not found!\n");
2589 goto out;
2590 }
2591 renew_client(clp);
2592 status = nfserr_cb_path_down;
NeilBrownea1da632005-06-23 22:04:17 -07002593 if (!list_empty(&clp->cl_delegations)
J. Bruce Fields2bf23872010-03-08 12:37:27 -05002594 && !atomic_read(&clp->cl_cb_set))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002595 goto out;
2596 status = nfs_ok;
2597out:
2598 nfs4_unlock_state();
2599 return status;
2600}
2601
J. Bruce Fieldsaf558e32007-09-06 12:34:25 -04002602struct lock_manager nfsd4_manager = {
2603};
2604
NeilBrowna76b4312005-06-23 22:04:01 -07002605static void
J. Bruce Fieldsaf558e32007-09-06 12:34:25 -04002606nfsd4_end_grace(void)
NeilBrowna76b4312005-06-23 22:04:01 -07002607{
2608 dprintk("NFSD: end of grace period\n");
NeilBrownc7b9a452005-06-23 22:04:30 -07002609 nfsd4_recdir_purge_old();
J. Bruce Fieldsaf558e32007-09-06 12:34:25 -04002610 locks_end_grace(&nfsd4_manager);
J. Bruce Fieldse46b4982010-03-01 19:21:21 -05002611 /*
2612 * Now that every NFSv4 client has had the chance to recover and
2613 * to see the (possibly new, possibly shorter) lease time, we
2614 * can safely set the next grace time to the current lease time:
2615 */
2616 nfsd4_grace = nfsd4_lease;
NeilBrowna76b4312005-06-23 22:04:01 -07002617}
2618
NeilBrownfd39ca92005-06-23 22:04:03 -07002619static time_t
Linus Torvalds1da177e2005-04-16 15:20:36 -07002620nfs4_laundromat(void)
2621{
2622 struct nfs4_client *clp;
2623 struct nfs4_stateowner *sop;
2624 struct nfs4_delegation *dp;
2625 struct list_head *pos, *next, reaplist;
J. Bruce Fieldscf07d2e2010-02-28 23:20:19 -05002626 time_t cutoff = get_seconds() - nfsd4_lease;
2627 time_t t, clientid_val = nfsd4_lease;
2628 time_t u, test_val = nfsd4_lease;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002629
2630 nfs4_lock_state();
2631
2632 dprintk("NFSD: laundromat service - starting\n");
J. Bruce Fieldsaf558e32007-09-06 12:34:25 -04002633 if (locks_in_grace())
2634 nfsd4_end_grace();
Benny Halevy36acb662010-05-12 00:13:04 +03002635 INIT_LIST_HEAD(&reaplist);
2636 spin_lock(&client_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002637 list_for_each_safe(pos, next, &client_lru) {
2638 clp = list_entry(pos, struct nfs4_client, cl_lru);
2639 if (time_after((unsigned long)clp->cl_time, (unsigned long)cutoff)) {
2640 t = clp->cl_time - cutoff;
2641 if (clientid_val > t)
2642 clientid_val = t;
2643 break;
2644 }
Benny Halevyd7682982010-05-12 00:13:54 +03002645 if (atomic_read(&clp->cl_refcount)) {
2646 dprintk("NFSD: client in use (clientid %08x)\n",
2647 clp->cl_clientid.cl_id);
2648 continue;
2649 }
2650 unhash_client_locked(clp);
2651 list_add(&clp->cl_lru, &reaplist);
Benny Halevy36acb662010-05-12 00:13:04 +03002652 }
2653 spin_unlock(&client_lock);
2654 list_for_each_safe(pos, next, &reaplist) {
2655 clp = list_entry(pos, struct nfs4_client, cl_lru);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002656 dprintk("NFSD: purging unused client (clientid %08x)\n",
2657 clp->cl_clientid.cl_id);
NeilBrownc7b9a452005-06-23 22:04:30 -07002658 nfsd4_remove_clid_dir(clp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002659 expire_client(clp);
2660 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002661 spin_lock(&recall_lock);
2662 list_for_each_safe(pos, next, &del_recall_lru) {
2663 dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
2664 if (time_after((unsigned long)dp->dl_time, (unsigned long)cutoff)) {
2665 u = dp->dl_time - cutoff;
2666 if (test_val > u)
2667 test_val = u;
2668 break;
2669 }
2670 dprintk("NFSD: purging unused delegation dp %p, fp %p\n",
2671 dp, dp->dl_flock);
2672 list_move(&dp->dl_recall_lru, &reaplist);
2673 }
2674 spin_unlock(&recall_lock);
2675 list_for_each_safe(pos, next, &reaplist) {
2676 dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
2677 list_del_init(&dp->dl_recall_lru);
2678 unhash_delegation(dp);
2679 }
J. Bruce Fieldscf07d2e2010-02-28 23:20:19 -05002680 test_val = nfsd4_lease;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002681 list_for_each_safe(pos, next, &close_lru) {
2682 sop = list_entry(pos, struct nfs4_stateowner, so_close_lru);
2683 if (time_after((unsigned long)sop->so_time, (unsigned long)cutoff)) {
2684 u = sop->so_time - cutoff;
2685 if (test_val > u)
2686 test_val = u;
2687 break;
2688 }
2689 dprintk("NFSD: purging unused open stateowner (so_id %d)\n",
2690 sop->so_id);
J. Bruce Fieldsf044ff82009-01-11 15:24:04 -05002691 release_openowner(sop);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002692 }
2693 if (clientid_val < NFSD_LAUNDROMAT_MINTIMEOUT)
2694 clientid_val = NFSD_LAUNDROMAT_MINTIMEOUT;
2695 nfs4_unlock_state();
2696 return clientid_val;
2697}
2698
Harvey Harrisona254b242008-02-20 12:49:00 -08002699static struct workqueue_struct *laundry_wq;
2700static void laundromat_main(struct work_struct *);
2701static DECLARE_DELAYED_WORK(laundromat_work, laundromat_main);
2702
2703static void
David Howellsc4028952006-11-22 14:57:56 +00002704laundromat_main(struct work_struct *not_used)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002705{
2706 time_t t;
2707
2708 t = nfs4_laundromat();
2709 dprintk("NFSD: laundromat_main - sleeping for %ld seconds\n", t);
NeilBrown58da2822005-06-23 22:03:19 -07002710 queue_delayed_work(laundry_wq, &laundromat_work, t*HZ);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002711}
2712
NeilBrownfd39ca92005-06-23 22:04:03 -07002713static struct nfs4_stateowner *
NeilBrownf8816512005-07-07 17:59:25 -07002714search_close_lru(u32 st_id, int flags)
2715{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002716 struct nfs4_stateowner *local = NULL;
2717
Linus Torvalds1da177e2005-04-16 15:20:36 -07002718 if (flags & CLOSE_STATE) {
2719 list_for_each_entry(local, &close_lru, so_close_lru) {
2720 if (local->so_id == st_id)
2721 return local;
2722 }
2723 }
2724 return NULL;
2725}
2726
2727static inline int
2728nfs4_check_fh(struct svc_fh *fhp, struct nfs4_stateid *stp)
2729{
Josef "Jeff" Sipek7eaa36e2006-12-08 02:36:41 -08002730 return fhp->fh_dentry->d_inode != stp->st_vfs_file->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002731}
2732
2733static int
2734STALE_STATEID(stateid_t *stateid)
2735{
J. Bruce Fieldse4e83ea2010-04-22 16:21:39 -04002736 if (stateid->si_boot == boot_time)
2737 return 0;
2738 dprintk("NFSD: stale stateid " STATEID_FMT "!\n",
Benny Halevy8c10cbd2009-10-19 12:04:53 +02002739 STATEID_VAL(stateid));
J. Bruce Fieldse4e83ea2010-04-22 16:21:39 -04002740 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002741}
2742
2743static inline int
2744access_permit_read(unsigned long access_bmap)
2745{
2746 return test_bit(NFS4_SHARE_ACCESS_READ, &access_bmap) ||
2747 test_bit(NFS4_SHARE_ACCESS_BOTH, &access_bmap) ||
2748 test_bit(NFS4_SHARE_ACCESS_WRITE, &access_bmap);
2749}
2750
2751static inline int
2752access_permit_write(unsigned long access_bmap)
2753{
2754 return test_bit(NFS4_SHARE_ACCESS_WRITE, &access_bmap) ||
2755 test_bit(NFS4_SHARE_ACCESS_BOTH, &access_bmap);
2756}
2757
2758static
Al Virob37ad282006-10-19 23:28:59 -07002759__be32 nfs4_check_openmode(struct nfs4_stateid *stp, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002760{
Al Virob37ad282006-10-19 23:28:59 -07002761 __be32 status = nfserr_openmode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002762
2763 if ((flags & WR_STATE) && (!access_permit_write(stp->st_access_bmap)))
2764 goto out;
2765 if ((flags & RD_STATE) && (!access_permit_read(stp->st_access_bmap)))
2766 goto out;
2767 status = nfs_ok;
2768out:
2769 return status;
2770}
2771
Al Virob37ad282006-10-19 23:28:59 -07002772static inline __be32
Linus Torvalds1da177e2005-04-16 15:20:36 -07002773check_special_stateids(svc_fh *current_fh, stateid_t *stateid, int flags)
2774{
J. Bruce Fields203a8c82009-02-21 13:29:14 -08002775 if (ONE_STATEID(stateid) && (flags & RD_STATE))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002776 return nfs_ok;
J. Bruce Fieldsaf558e32007-09-06 12:34:25 -04002777 else if (locks_in_grace()) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002778 /* Answer in remaining cases depends on existance of
2779 * conflicting state; so we must wait out the grace period. */
2780 return nfserr_grace;
2781 } else if (flags & WR_STATE)
2782 return nfs4_share_conflict(current_fh,
2783 NFS4_SHARE_DENY_WRITE);
2784 else /* (flags & RD_STATE) && ZERO_STATEID(stateid) */
2785 return nfs4_share_conflict(current_fh,
2786 NFS4_SHARE_DENY_READ);
2787}
2788
2789/*
2790 * Allow READ/WRITE during grace period on recovered state only for files
2791 * that are not able to provide mandatory locking.
2792 */
2793static inline int
J. Bruce Fields18f82732009-02-21 15:23:01 -08002794grace_disallows_io(struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002795{
J. Bruce Fields203a8c82009-02-21 13:29:14 -08002796 return locks_in_grace() && mandatory_lock(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002797}
2798
Andy Adamson66689582009-04-03 08:28:45 +03002799static int check_stateid_generation(stateid_t *in, stateid_t *ref, int flags)
J. Bruce Fields0836f582008-01-26 19:08:12 -05002800{
Andy Adamson66689582009-04-03 08:28:45 +03002801 /*
2802 * When sessions are used the stateid generation number is ignored
2803 * when it is zero.
2804 */
2805 if ((flags & HAS_SESSION) && in->si_generation == 0)
2806 goto out;
2807
J. Bruce Fields0836f582008-01-26 19:08:12 -05002808 /* If the client sends us a stateid from the future, it's buggy: */
2809 if (in->si_generation > ref->si_generation)
2810 return nfserr_bad_stateid;
2811 /*
2812 * The following, however, can happen. For example, if the
2813 * client sends an open and some IO at the same time, the open
2814 * may bump si_generation while the IO is still in flight.
2815 * Thanks to hard links and renames, the client never knows what
2816 * file an open will affect. So it could avoid that situation
2817 * only by serializing all opens and IO from the same open
2818 * owner. To recover from the old_stateid error, the client
2819 * will just have to retry the IO:
2820 */
2821 if (in->si_generation < ref->si_generation)
2822 return nfserr_old_stateid;
Andy Adamson66689582009-04-03 08:28:45 +03002823out:
J. Bruce Fields0836f582008-01-26 19:08:12 -05002824 return nfs_ok;
2825}
2826
J. Bruce Fields3e633072009-02-21 13:17:19 -08002827static int is_delegation_stateid(stateid_t *stateid)
2828{
2829 return stateid->si_fileid == 0;
2830}
2831
Linus Torvalds1da177e2005-04-16 15:20:36 -07002832/*
2833* Checks for stateid operations
2834*/
Al Virob37ad282006-10-19 23:28:59 -07002835__be32
Benny Halevydd453df2009-04-03 08:28:41 +03002836nfs4_preprocess_stateid_op(struct nfsd4_compound_state *cstate,
2837 stateid_t *stateid, int flags, struct file **filpp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002838{
2839 struct nfs4_stateid *stp = NULL;
2840 struct nfs4_delegation *dp = NULL;
Benny Halevydd453df2009-04-03 08:28:41 +03002841 struct svc_fh *current_fh = &cstate->current_fh;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002842 struct inode *ino = current_fh->fh_dentry->d_inode;
Al Virob37ad282006-10-19 23:28:59 -07002843 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002844
Linus Torvalds1da177e2005-04-16 15:20:36 -07002845 if (filpp)
2846 *filpp = NULL;
2847
J. Bruce Fields18f82732009-02-21 15:23:01 -08002848 if (grace_disallows_io(ino))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002849 return nfserr_grace;
2850
Andy Adamson66689582009-04-03 08:28:45 +03002851 if (nfsd4_has_session(cstate))
2852 flags |= HAS_SESSION;
2853
Linus Torvalds1da177e2005-04-16 15:20:36 -07002854 if (ZERO_STATEID(stateid) || ONE_STATEID(stateid))
2855 return check_special_stateids(current_fh, stateid, flags);
2856
Linus Torvalds1da177e2005-04-16 15:20:36 -07002857 status = nfserr_stale_stateid;
2858 if (STALE_STATEID(stateid))
2859 goto out;
2860
Linus Torvalds1da177e2005-04-16 15:20:36 -07002861 status = nfserr_bad_stateid;
J. Bruce Fields3e633072009-02-21 13:17:19 -08002862 if (is_delegation_stateid(stateid)) {
J. Bruce Fieldsa4455be2009-02-21 10:40:22 -08002863 dp = find_delegation_stateid(ino, stateid);
J. Bruce Fieldse4e83ea2010-04-22 16:21:39 -04002864 if (!dp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002865 goto out;
Andy Adamson66689582009-04-03 08:28:45 +03002866 status = check_stateid_generation(stateid, &dp->dl_stateid,
2867 flags);
J. Bruce Fields0c2a4982009-02-21 11:11:50 -08002868 if (status)
2869 goto out;
J. Bruce Fieldsdc9bf702009-02-21 11:14:43 -08002870 status = nfs4_check_delegmode(dp, flags);
2871 if (status)
2872 goto out;
2873 renew_client(dp->dl_client);
J. Bruce Fieldsdc9bf702009-02-21 11:14:43 -08002874 if (filpp)
2875 *filpp = dp->dl_vfs_file;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002876 } else { /* open or lock stateid */
J. Bruce Fieldsa4455be2009-02-21 10:40:22 -08002877 stp = find_stateid(stateid, flags);
J. Bruce Fieldse4e83ea2010-04-22 16:21:39 -04002878 if (!stp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002879 goto out;
J. Bruce Fields6150ef02009-02-21 13:36:16 -08002880 if (nfs4_check_fh(current_fh, stp))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002881 goto out;
2882 if (!stp->st_stateowner->so_confirmed)
2883 goto out;
Andy Adamson66689582009-04-03 08:28:45 +03002884 status = check_stateid_generation(stateid, &stp->st_stateid,
2885 flags);
J. Bruce Fields0c2a4982009-02-21 11:11:50 -08002886 if (status)
2887 goto out;
J. Bruce Fieldsa4455be2009-02-21 10:40:22 -08002888 status = nfs4_check_openmode(stp, flags);
2889 if (status)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002890 goto out;
2891 renew_client(stp->st_stateowner->so_client);
2892 if (filpp)
2893 *filpp = stp->st_vfs_file;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002894 }
2895 status = nfs_ok;
2896out:
2897 return status;
2898}
2899
NeilBrown4c4cd222005-07-07 17:59:27 -07002900static inline int
2901setlkflg (int type)
2902{
2903 return (type == NFS4_READW_LT || type == NFS4_READ_LT) ?
2904 RD_STATE : WR_STATE;
2905}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002906
2907/*
2908 * Checks for sequence id mutating operations.
2909 */
Al Virob37ad282006-10-19 23:28:59 -07002910static __be32
Benny Halevydd453df2009-04-03 08:28:41 +03002911nfs4_preprocess_seqid_op(struct nfsd4_compound_state *cstate, u32 seqid,
2912 stateid_t *stateid, int flags,
2913 struct nfs4_stateowner **sopp,
2914 struct nfs4_stateid **stpp, struct nfsd4_lock *lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002915{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002916 struct nfs4_stateid *stp;
2917 struct nfs4_stateowner *sop;
Benny Halevydd453df2009-04-03 08:28:41 +03002918 struct svc_fh *current_fh = &cstate->current_fh;
J. Bruce Fields0836f582008-01-26 19:08:12 -05002919 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002920
Benny Halevy8c10cbd2009-10-19 12:04:53 +02002921 dprintk("NFSD: %s: seqid=%d stateid = " STATEID_FMT "\n", __func__,
2922 seqid, STATEID_VAL(stateid));
NeilBrown3a4f98b2005-07-07 17:59:26 -07002923
Linus Torvalds1da177e2005-04-16 15:20:36 -07002924 *stpp = NULL;
2925 *sopp = NULL;
2926
Linus Torvalds1da177e2005-04-16 15:20:36 -07002927 if (ZERO_STATEID(stateid) || ONE_STATEID(stateid)) {
J. Bruce Fields2fdada02007-07-27 16:10:37 -04002928 dprintk("NFSD: preprocess_seqid_op: magic stateid!\n");
NeilBrown3a4f98b2005-07-07 17:59:26 -07002929 return nfserr_bad_stateid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002930 }
2931
Linus Torvalds1da177e2005-04-16 15:20:36 -07002932 if (STALE_STATEID(stateid))
NeilBrown3a4f98b2005-07-07 17:59:26 -07002933 return nfserr_stale_stateid;
Andy Adamson66689582009-04-03 08:28:45 +03002934
2935 if (nfsd4_has_session(cstate))
2936 flags |= HAS_SESSION;
2937
Linus Torvalds1da177e2005-04-16 15:20:36 -07002938 /*
2939 * We return BAD_STATEID if filehandle doesn't match stateid,
2940 * the confirmed flag is incorrecly set, or the generation
2941 * number is incorrect.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002942 */
NeilBrownf8816512005-07-07 17:59:25 -07002943 stp = find_stateid(stateid, flags);
2944 if (stp == NULL) {
2945 /*
2946 * Also, we should make sure this isn't just the result of
2947 * a replayed close:
2948 */
2949 sop = search_close_lru(stateid->si_stateownerid, flags);
2950 if (sop == NULL)
J. Bruce Fieldse4e83ea2010-04-22 16:21:39 -04002951 return nfserr_bad_stateid;
NeilBrownf8816512005-07-07 17:59:25 -07002952 *sopp = sop;
2953 goto check_replay;
2954 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002955
J. Bruce Fields39325bd2007-11-26 17:06:39 -05002956 *stpp = stp;
2957 *sopp = sop = stp->st_stateowner;
2958
NeilBrown4c4cd222005-07-07 17:59:27 -07002959 if (lock) {
NeilBrown4c4cd222005-07-07 17:59:27 -07002960 clientid_t *lockclid = &lock->v.new.clientid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002961 struct nfs4_client *clp = sop->so_client;
NeilBrown4c4cd222005-07-07 17:59:27 -07002962 int lkflg = 0;
Al Virob37ad282006-10-19 23:28:59 -07002963 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002964
NeilBrown4c4cd222005-07-07 17:59:27 -07002965 lkflg = setlkflg(lock->lk_type);
2966
2967 if (lock->lk_is_new) {
J. Bruce Fields599e0a22007-07-26 17:04:54 -04002968 if (!sop->so_is_open_owner)
2969 return nfserr_bad_stateid;
Andy Adamson60adfc52009-04-03 08:28:50 +03002970 if (!(flags & HAS_SESSION) &&
2971 !same_clid(&clp->cl_clientid, lockclid))
2972 return nfserr_bad_stateid;
J. Bruce Fields599e0a22007-07-26 17:04:54 -04002973 /* stp is the open stateid */
2974 status = nfs4_check_openmode(stp, lkflg);
2975 if (status)
2976 return status;
2977 } else {
2978 /* stp is the lock stateid */
2979 status = nfs4_check_openmode(stp->st_openstp, lkflg);
2980 if (status)
2981 return status;
NeilBrown4c4cd222005-07-07 17:59:27 -07002982 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002983 }
2984
J. Bruce Fieldsf3362732008-01-26 14:58:45 -05002985 if (nfs4_check_fh(current_fh, stp)) {
J. Bruce Fields2fdada02007-07-27 16:10:37 -04002986 dprintk("NFSD: preprocess_seqid_op: fh-stateid mismatch!\n");
NeilBrown3a4f98b2005-07-07 17:59:26 -07002987 return nfserr_bad_stateid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002988 }
2989
Linus Torvalds1da177e2005-04-16 15:20:36 -07002990 /*
2991 * We now validate the seqid and stateid generation numbers.
2992 * For the moment, we ignore the possibility of
2993 * generation number wraparound.
2994 */
Andy Adamson66689582009-04-03 08:28:45 +03002995 if (!(flags & HAS_SESSION) && seqid != sop->so_seqid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002996 goto check_replay;
2997
NeilBrown3a4f98b2005-07-07 17:59:26 -07002998 if (sop->so_confirmed && flags & CONFIRM) {
J. Bruce Fields2fdada02007-07-27 16:10:37 -04002999 dprintk("NFSD: preprocess_seqid_op: expected"
NeilBrown3a4f98b2005-07-07 17:59:26 -07003000 " unconfirmed stateowner!\n");
3001 return nfserr_bad_stateid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003002 }
NeilBrown3a4f98b2005-07-07 17:59:26 -07003003 if (!sop->so_confirmed && !(flags & CONFIRM)) {
J. Bruce Fields2fdada02007-07-27 16:10:37 -04003004 dprintk("NFSD: preprocess_seqid_op: stateowner not"
NeilBrown3a4f98b2005-07-07 17:59:26 -07003005 " confirmed yet!\n");
3006 return nfserr_bad_stateid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003007 }
Andy Adamson66689582009-04-03 08:28:45 +03003008 status = check_stateid_generation(stateid, &stp->st_stateid, flags);
J. Bruce Fields0836f582008-01-26 19:08:12 -05003009 if (status)
3010 return status;
NeilBrown52fd0042005-07-07 17:59:24 -07003011 renew_client(sop->so_client);
NeilBrown3a4f98b2005-07-07 17:59:26 -07003012 return nfs_ok;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003013
Linus Torvalds1da177e2005-04-16 15:20:36 -07003014check_replay:
NeilBrownbd9aac52005-07-07 17:59:19 -07003015 if (seqid == sop->so_seqid - 1) {
Neil Brown849823c2005-09-13 01:25:36 -07003016 dprintk("NFSD: preprocess_seqid_op: retransmission?\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003017 /* indicate replay to calling function */
Al Viroa90b0612006-10-19 23:29:03 -07003018 return nfserr_replay_me;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003019 }
J. Bruce Fields2fdada02007-07-27 16:10:37 -04003020 dprintk("NFSD: preprocess_seqid_op: bad seqid (expected %d, got %d)\n",
NeilBrown3a4f98b2005-07-07 17:59:26 -07003021 sop->so_seqid, seqid);
3022 *sopp = NULL;
3023 return nfserr_bad_seqid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003024}
3025
Al Virob37ad282006-10-19 23:28:59 -07003026__be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003027nfsd4_open_confirm(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
J.Bruce Fieldsa4f1706a92006-12-13 00:35:28 -08003028 struct nfsd4_open_confirm *oc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003029{
Al Virob37ad282006-10-19 23:28:59 -07003030 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003031 struct nfs4_stateowner *sop;
3032 struct nfs4_stateid *stp;
3033
3034 dprintk("NFSD: nfsd4_open_confirm on file %.*s\n",
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003035 (int)cstate->current_fh.fh_dentry->d_name.len,
3036 cstate->current_fh.fh_dentry->d_name.name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003037
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003038 status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0);
J. Bruce Fieldsa8cddc52006-06-30 01:56:13 -07003039 if (status)
3040 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003041
3042 nfs4_lock_state();
3043
Benny Halevydd453df2009-04-03 08:28:41 +03003044 if ((status = nfs4_preprocess_seqid_op(cstate,
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003045 oc->oc_seqid, &oc->oc_req_stateid,
J. Bruce Fieldsf3362732008-01-26 14:58:45 -05003046 CONFIRM | OPEN_STATE,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003047 &oc->oc_stateowner, &stp, NULL)))
3048 goto out;
3049
3050 sop = oc->oc_stateowner;
3051 sop->so_confirmed = 1;
3052 update_stateid(&stp->st_stateid);
3053 memcpy(&oc->oc_resp_stateid, &stp->st_stateid, sizeof(stateid_t));
Benny Halevy8c10cbd2009-10-19 12:04:53 +02003054 dprintk("NFSD: %s: success, seqid=%d stateid=" STATEID_FMT "\n",
3055 __func__, oc->oc_seqid, STATEID_VAL(&stp->st_stateid));
NeilBrownc7b9a452005-06-23 22:04:30 -07003056
3057 nfsd4_create_clid_dir(sop->so_client);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003058out:
Neil Brownf2327d92005-09-13 01:25:37 -07003059 if (oc->oc_stateowner) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003060 nfs4_get_stateowner(oc->oc_stateowner);
J.Bruce Fieldsa4f1706a92006-12-13 00:35:28 -08003061 cstate->replay_owner = oc->oc_stateowner;
Neil Brownf2327d92005-09-13 01:25:37 -07003062 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003063 nfs4_unlock_state();
3064 return status;
3065}
3066
3067
3068/*
3069 * unset all bits in union bitmap (bmap) that
3070 * do not exist in share (from successful OPEN_DOWNGRADE)
3071 */
3072static void
3073reset_union_bmap_access(unsigned long access, unsigned long *bmap)
3074{
3075 int i;
3076 for (i = 1; i < 4; i++) {
3077 if ((i & access) != i)
3078 __clear_bit(i, bmap);
3079 }
3080}
3081
3082static void
3083reset_union_bmap_deny(unsigned long deny, unsigned long *bmap)
3084{
3085 int i;
3086 for (i = 0; i < 4; i++) {
3087 if ((i & deny) != i)
3088 __clear_bit(i, bmap);
3089 }
3090}
3091
Al Virob37ad282006-10-19 23:28:59 -07003092__be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003093nfsd4_open_downgrade(struct svc_rqst *rqstp,
3094 struct nfsd4_compound_state *cstate,
J.Bruce Fieldsa4f1706a92006-12-13 00:35:28 -08003095 struct nfsd4_open_downgrade *od)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003096{
Al Virob37ad282006-10-19 23:28:59 -07003097 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003098 struct nfs4_stateid *stp;
3099 unsigned int share_access;
3100
3101 dprintk("NFSD: nfsd4_open_downgrade on file %.*s\n",
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003102 (int)cstate->current_fh.fh_dentry->d_name.len,
3103 cstate->current_fh.fh_dentry->d_name.name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003104
Andy Adamsond87a8ad2009-04-03 08:28:53 +03003105 if (!access_valid(od->od_share_access, cstate->minorversion)
J. Bruce Fieldsba5a6a12006-06-30 01:56:16 -07003106 || !deny_valid(od->od_share_deny))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003107 return nfserr_inval;
3108
3109 nfs4_lock_state();
Benny Halevydd453df2009-04-03 08:28:41 +03003110 if ((status = nfs4_preprocess_seqid_op(cstate,
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003111 od->od_seqid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003112 &od->od_stateid,
J. Bruce Fieldsf3362732008-01-26 14:58:45 -05003113 OPEN_STATE,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003114 &od->od_stateowner, &stp, NULL)))
3115 goto out;
3116
3117 status = nfserr_inval;
3118 if (!test_bit(od->od_share_access, &stp->st_access_bmap)) {
3119 dprintk("NFSD:access not a subset current bitmap: 0x%lx, input access=%08x\n",
3120 stp->st_access_bmap, od->od_share_access);
3121 goto out;
3122 }
3123 if (!test_bit(od->od_share_deny, &stp->st_deny_bmap)) {
3124 dprintk("NFSD:deny not a subset current bitmap: 0x%lx, input deny=%08x\n",
3125 stp->st_deny_bmap, od->od_share_deny);
3126 goto out;
3127 }
3128 set_access(&share_access, stp->st_access_bmap);
3129 nfs4_file_downgrade(stp->st_vfs_file,
3130 share_access & ~od->od_share_access);
3131
3132 reset_union_bmap_access(od->od_share_access, &stp->st_access_bmap);
3133 reset_union_bmap_deny(od->od_share_deny, &stp->st_deny_bmap);
3134
3135 update_stateid(&stp->st_stateid);
3136 memcpy(&od->od_stateid, &stp->st_stateid, sizeof(stateid_t));
3137 status = nfs_ok;
3138out:
Neil Brownf2327d92005-09-13 01:25:37 -07003139 if (od->od_stateowner) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003140 nfs4_get_stateowner(od->od_stateowner);
J.Bruce Fieldsa4f1706a92006-12-13 00:35:28 -08003141 cstate->replay_owner = od->od_stateowner;
Neil Brownf2327d92005-09-13 01:25:37 -07003142 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003143 nfs4_unlock_state();
3144 return status;
3145}
3146
3147/*
3148 * nfs4_unlock_state() called after encode
3149 */
Al Virob37ad282006-10-19 23:28:59 -07003150__be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003151nfsd4_close(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
J.Bruce Fieldsa4f1706a92006-12-13 00:35:28 -08003152 struct nfsd4_close *close)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003153{
Al Virob37ad282006-10-19 23:28:59 -07003154 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003155 struct nfs4_stateid *stp;
3156
3157 dprintk("NFSD: nfsd4_close on file %.*s\n",
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003158 (int)cstate->current_fh.fh_dentry->d_name.len,
3159 cstate->current_fh.fh_dentry->d_name.name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003160
3161 nfs4_lock_state();
3162 /* check close_lru for replay */
Benny Halevydd453df2009-04-03 08:28:41 +03003163 if ((status = nfs4_preprocess_seqid_op(cstate,
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003164 close->cl_seqid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003165 &close->cl_stateid,
J. Bruce Fieldsf3362732008-01-26 14:58:45 -05003166 OPEN_STATE | CLOSE_STATE,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003167 &close->cl_stateowner, &stp, NULL)))
3168 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003169 status = nfs_ok;
3170 update_stateid(&stp->st_stateid);
3171 memcpy(&close->cl_stateid, &stp->st_stateid, sizeof(stateid_t));
3172
J. Bruce Fields04ef5952006-01-18 17:43:21 -08003173 /* release_stateid() calls nfsd_close() if needed */
J. Bruce Fields22839632009-01-11 14:27:17 -05003174 release_open_stateid(stp);
J. Bruce Fields04ef5952006-01-18 17:43:21 -08003175
3176 /* place unused nfs4_stateowners on so_close_lru list to be
3177 * released by the laundromat service after the lease period
3178 * to enable us to handle CLOSE replay
3179 */
3180 if (list_empty(&close->cl_stateowner->so_stateids))
3181 move_to_close_lru(close->cl_stateowner);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003182out:
Neil Brownf2327d92005-09-13 01:25:37 -07003183 if (close->cl_stateowner) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003184 nfs4_get_stateowner(close->cl_stateowner);
J.Bruce Fieldsa4f1706a92006-12-13 00:35:28 -08003185 cstate->replay_owner = close->cl_stateowner;
Neil Brownf2327d92005-09-13 01:25:37 -07003186 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003187 nfs4_unlock_state();
3188 return status;
3189}
3190
Al Virob37ad282006-10-19 23:28:59 -07003191__be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003192nfsd4_delegreturn(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
3193 struct nfsd4_delegreturn *dr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003194{
J. Bruce Fields203a8c82009-02-21 13:29:14 -08003195 struct nfs4_delegation *dp;
3196 stateid_t *stateid = &dr->dr_stateid;
3197 struct inode *inode;
Al Virob37ad282006-10-19 23:28:59 -07003198 __be32 status;
Andy Adamson66689582009-04-03 08:28:45 +03003199 int flags = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003200
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003201 if ((status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0)))
J. Bruce Fields203a8c82009-02-21 13:29:14 -08003202 return status;
3203 inode = cstate->current_fh.fh_dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003204
Andy Adamson66689582009-04-03 08:28:45 +03003205 if (nfsd4_has_session(cstate))
3206 flags |= HAS_SESSION;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003207 nfs4_lock_state();
J. Bruce Fields203a8c82009-02-21 13:29:14 -08003208 status = nfserr_bad_stateid;
3209 if (ZERO_STATEID(stateid) || ONE_STATEID(stateid))
3210 goto out;
3211 status = nfserr_stale_stateid;
3212 if (STALE_STATEID(stateid))
3213 goto out;
J. Bruce Fields7e0f7cf2009-02-21 13:32:28 -08003214 status = nfserr_bad_stateid;
J. Bruce Fields203a8c82009-02-21 13:29:14 -08003215 if (!is_delegation_stateid(stateid))
3216 goto out;
J. Bruce Fields203a8c82009-02-21 13:29:14 -08003217 dp = find_delegation_stateid(inode, stateid);
J. Bruce Fieldse4e83ea2010-04-22 16:21:39 -04003218 if (!dp)
J. Bruce Fields203a8c82009-02-21 13:29:14 -08003219 goto out;
Andy Adamson66689582009-04-03 08:28:45 +03003220 status = check_stateid_generation(stateid, &dp->dl_stateid, flags);
J. Bruce Fields203a8c82009-02-21 13:29:14 -08003221 if (status)
3222 goto out;
3223 renew_client(dp->dl_client);
3224
3225 unhash_delegation(dp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003226out:
J. Bruce Fields203a8c82009-02-21 13:29:14 -08003227 nfs4_unlock_state();
3228
Linus Torvalds1da177e2005-04-16 15:20:36 -07003229 return status;
3230}
3231
3232
3233/*
3234 * Lock owner state (byte-range locks)
3235 */
3236#define LOFF_OVERFLOW(start, len) ((u64)(len) > ~(u64)(start))
3237#define LOCK_HASH_BITS 8
3238#define LOCK_HASH_SIZE (1 << LOCK_HASH_BITS)
3239#define LOCK_HASH_MASK (LOCK_HASH_SIZE - 1)
3240
Benny Halevy87df4de2008-12-15 19:42:03 +02003241static inline u64
3242end_offset(u64 start, u64 len)
3243{
3244 u64 end;
3245
3246 end = start + len;
3247 return end >= start ? end: NFS4_MAX_UINT64;
3248}
3249
3250/* last octet in a range */
3251static inline u64
3252last_byte_offset(u64 start, u64 len)
3253{
3254 u64 end;
3255
3256 BUG_ON(!len);
3257 end = start + len;
3258 return end > start ? end - 1: NFS4_MAX_UINT64;
3259}
3260
Linus Torvalds1da177e2005-04-16 15:20:36 -07003261#define lockownerid_hashval(id) \
3262 ((id) & LOCK_HASH_MASK)
3263
3264static inline unsigned int
3265lock_ownerstr_hashval(struct inode *inode, u32 cl_id,
3266 struct xdr_netobj *ownername)
3267{
3268 return (file_hashval(inode) + cl_id
3269 + opaque_hashval(ownername->data, ownername->len))
3270 & LOCK_HASH_MASK;
3271}
3272
3273static struct list_head lock_ownerid_hashtbl[LOCK_HASH_SIZE];
3274static struct list_head lock_ownerstr_hashtbl[LOCK_HASH_SIZE];
3275static struct list_head lockstateid_hashtbl[STATEID_HASH_SIZE];
3276
NeilBrownfd39ca92005-06-23 22:04:03 -07003277static struct nfs4_stateid *
Linus Torvalds1da177e2005-04-16 15:20:36 -07003278find_stateid(stateid_t *stid, int flags)
3279{
Krishna Kumar9346eff2008-10-20 11:44:28 +05303280 struct nfs4_stateid *local;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003281 u32 st_id = stid->si_stateownerid;
3282 u32 f_id = stid->si_fileid;
3283 unsigned int hashval;
3284
3285 dprintk("NFSD: find_stateid flags 0x%x\n",flags);
Krishna Kumar9346eff2008-10-20 11:44:28 +05303286 if (flags & (LOCK_STATE | RD_STATE | WR_STATE)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003287 hashval = stateid_hashval(st_id, f_id);
3288 list_for_each_entry(local, &lockstateid_hashtbl[hashval], st_hash) {
3289 if ((local->st_stateid.si_stateownerid == st_id) &&
3290 (local->st_stateid.si_fileid == f_id))
3291 return local;
3292 }
3293 }
Krishna Kumar9346eff2008-10-20 11:44:28 +05303294
3295 if (flags & (OPEN_STATE | RD_STATE | WR_STATE)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003296 hashval = stateid_hashval(st_id, f_id);
3297 list_for_each_entry(local, &stateid_hashtbl[hashval], st_hash) {
3298 if ((local->st_stateid.si_stateownerid == st_id) &&
3299 (local->st_stateid.si_fileid == f_id))
3300 return local;
3301 }
Neil Brown849823c2005-09-13 01:25:36 -07003302 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003303 return NULL;
3304}
3305
3306static struct nfs4_delegation *
3307find_delegation_stateid(struct inode *ino, stateid_t *stid)
3308{
NeilBrown13cd2182005-06-23 22:03:10 -07003309 struct nfs4_file *fp;
3310 struct nfs4_delegation *dl;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003311
Benny Halevy8c10cbd2009-10-19 12:04:53 +02003312 dprintk("NFSD: %s: stateid=" STATEID_FMT "\n", __func__,
3313 STATEID_VAL(stid));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003314
Linus Torvalds1da177e2005-04-16 15:20:36 -07003315 fp = find_file(ino);
NeilBrown13cd2182005-06-23 22:03:10 -07003316 if (!fp)
3317 return NULL;
3318 dl = find_delegation_file(fp, stid);
3319 put_nfs4_file(fp);
3320 return dl;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003321}
3322
3323/*
3324 * TODO: Linux file offsets are _signed_ 64-bit quantities, which means that
3325 * we can't properly handle lock requests that go beyond the (2^63 - 1)-th
3326 * byte, because of sign extension problems. Since NFSv4 calls for 64-bit
3327 * locking, this prevents us from being completely protocol-compliant. The
3328 * real solution to this problem is to start using unsigned file offsets in
3329 * the VFS, but this is a very deep change!
3330 */
3331static inline void
3332nfs4_transform_lock_offset(struct file_lock *lock)
3333{
3334 if (lock->fl_start < 0)
3335 lock->fl_start = OFFSET_MAX;
3336 if (lock->fl_end < 0)
3337 lock->fl_end = OFFSET_MAX;
3338}
3339
NeilBrownd5b90262006-04-10 22:55:22 -07003340/* Hack!: For now, we're defining this just so we can use a pointer to it
3341 * as a unique cookie to identify our (NFSv4's) posix locks. */
Alexey Dobriyan7b021962009-09-21 17:01:12 -07003342static const struct lock_manager_operations nfsd_posix_mng_ops = {
NeilBrownd5b90262006-04-10 22:55:22 -07003343};
Linus Torvalds1da177e2005-04-16 15:20:36 -07003344
3345static inline void
3346nfs4_set_lock_denied(struct file_lock *fl, struct nfsd4_lock_denied *deny)
3347{
NeilBrownd5b90262006-04-10 22:55:22 -07003348 struct nfs4_stateowner *sop;
3349 unsigned int hval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003350
NeilBrownd5b90262006-04-10 22:55:22 -07003351 if (fl->fl_lmops == &nfsd_posix_mng_ops) {
3352 sop = (struct nfs4_stateowner *) fl->fl_owner;
3353 hval = lockownerid_hashval(sop->so_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003354 kref_get(&sop->so_ref);
3355 deny->ld_sop = sop;
3356 deny->ld_clientid = sop->so_client->cl_clientid;
NeilBrownd5b90262006-04-10 22:55:22 -07003357 } else {
3358 deny->ld_sop = NULL;
3359 deny->ld_clientid.cl_boot = 0;
3360 deny->ld_clientid.cl_id = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003361 }
3362 deny->ld_start = fl->fl_start;
Benny Halevy87df4de2008-12-15 19:42:03 +02003363 deny->ld_length = NFS4_MAX_UINT64;
3364 if (fl->fl_end != NFS4_MAX_UINT64)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003365 deny->ld_length = fl->fl_end - fl->fl_start + 1;
3366 deny->ld_type = NFS4_READ_LT;
3367 if (fl->fl_type != F_RDLCK)
3368 deny->ld_type = NFS4_WRITE_LT;
3369}
3370
3371static struct nfs4_stateowner *
Linus Torvalds1da177e2005-04-16 15:20:36 -07003372find_lockstateowner_str(struct inode *inode, clientid_t *clid,
3373 struct xdr_netobj *owner)
3374{
3375 unsigned int hashval = lock_ownerstr_hashval(inode, clid->cl_id, owner);
3376 struct nfs4_stateowner *op;
3377
3378 list_for_each_entry(op, &lock_ownerstr_hashtbl[hashval], so_strhash) {
J. Bruce Fields599e0a22007-07-26 17:04:54 -04003379 if (same_owner_str(op, owner, clid))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003380 return op;
3381 }
3382 return NULL;
3383}
3384
3385/*
3386 * Alloc a lock owner structure.
3387 * Called in nfsd4_lock - therefore, OPEN and OPEN_CONFIRM (if needed) has
3388 * occured.
3389 *
3390 * strhashval = lock_ownerstr_hashval
Linus Torvalds1da177e2005-04-16 15:20:36 -07003391 */
3392
3393static struct nfs4_stateowner *
3394alloc_init_lock_stateowner(unsigned int strhashval, struct nfs4_client *clp, struct nfs4_stateid *open_stp, struct nfsd4_lock *lock) {
3395 struct nfs4_stateowner *sop;
3396 struct nfs4_replay *rp;
3397 unsigned int idhashval;
3398
3399 if (!(sop = alloc_stateowner(&lock->lk_new_owner)))
3400 return NULL;
3401 idhashval = lockownerid_hashval(current_ownerid);
3402 INIT_LIST_HEAD(&sop->so_idhash);
3403 INIT_LIST_HEAD(&sop->so_strhash);
3404 INIT_LIST_HEAD(&sop->so_perclient);
NeilBrownea1da632005-06-23 22:04:17 -07003405 INIT_LIST_HEAD(&sop->so_stateids);
3406 INIT_LIST_HEAD(&sop->so_perstateid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003407 INIT_LIST_HEAD(&sop->so_close_lru); /* not used */
3408 sop->so_time = 0;
3409 list_add(&sop->so_idhash, &lock_ownerid_hashtbl[idhashval]);
3410 list_add(&sop->so_strhash, &lock_ownerstr_hashtbl[strhashval]);
NeilBrownea1da632005-06-23 22:04:17 -07003411 list_add(&sop->so_perstateid, &open_stp->st_lockowners);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003412 sop->so_is_open_owner = 0;
3413 sop->so_id = current_ownerid++;
3414 sop->so_client = clp;
Neil Brownb59e3c02005-09-13 01:25:38 -07003415 /* It is the openowner seqid that will be incremented in encode in the
3416 * case of new lockowners; so increment the lock seqid manually: */
3417 sop->so_seqid = lock->lk_new_lock_seqid + 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003418 sop->so_confirmed = 1;
3419 rp = &sop->so_replay;
Al Virode1ae282006-01-18 17:43:47 -08003420 rp->rp_status = nfserr_serverfault;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003421 rp->rp_buflen = 0;
3422 rp->rp_buf = rp->rp_ibuf;
3423 return sop;
3424}
3425
NeilBrownfd39ca92005-06-23 22:04:03 -07003426static struct nfs4_stateid *
Linus Torvalds1da177e2005-04-16 15:20:36 -07003427alloc_init_lock_stateid(struct nfs4_stateowner *sop, struct nfs4_file *fp, struct nfs4_stateid *open_stp)
3428{
3429 struct nfs4_stateid *stp;
3430 unsigned int hashval = stateid_hashval(sop->so_id, fp->fi_id);
3431
NeilBrown5ac049a2005-06-23 22:03:03 -07003432 stp = nfs4_alloc_stateid();
3433 if (stp == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003434 goto out;
3435 INIT_LIST_HEAD(&stp->st_hash);
3436 INIT_LIST_HEAD(&stp->st_perfile);
NeilBrownea1da632005-06-23 22:04:17 -07003437 INIT_LIST_HEAD(&stp->st_perstateowner);
3438 INIT_LIST_HEAD(&stp->st_lockowners); /* not used */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003439 list_add(&stp->st_hash, &lockstateid_hashtbl[hashval]);
NeilBrown8beefa22005-06-23 22:03:08 -07003440 list_add(&stp->st_perfile, &fp->fi_stateids);
NeilBrownea1da632005-06-23 22:04:17 -07003441 list_add(&stp->st_perstateowner, &sop->so_stateids);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003442 stp->st_stateowner = sop;
NeilBrown13cd2182005-06-23 22:03:10 -07003443 get_nfs4_file(fp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003444 stp->st_file = fp;
J. Bruce Fieldse4e83ea2010-04-22 16:21:39 -04003445 stp->st_stateid.si_boot = boot_time;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003446 stp->st_stateid.si_stateownerid = sop->so_id;
3447 stp->st_stateid.si_fileid = fp->fi_id;
3448 stp->st_stateid.si_generation = 0;
3449 stp->st_vfs_file = open_stp->st_vfs_file; /* FIXME refcount?? */
3450 stp->st_access_bmap = open_stp->st_access_bmap;
3451 stp->st_deny_bmap = open_stp->st_deny_bmap;
NeilBrown4c4cd222005-07-07 17:59:27 -07003452 stp->st_openstp = open_stp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003453
3454out:
3455 return stp;
3456}
3457
NeilBrownfd39ca92005-06-23 22:04:03 -07003458static int
Linus Torvalds1da177e2005-04-16 15:20:36 -07003459check_lock_length(u64 offset, u64 length)
3460{
Benny Halevy87df4de2008-12-15 19:42:03 +02003461 return ((length == 0) || ((length != NFS4_MAX_UINT64) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07003462 LOFF_OVERFLOW(offset, length)));
3463}
3464
3465/*
3466 * LOCK operation
3467 */
Al Virob37ad282006-10-19 23:28:59 -07003468__be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003469nfsd4_lock(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
J.Bruce Fieldsa4f1706a92006-12-13 00:35:28 -08003470 struct nfsd4_lock *lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003471{
NeilBrown3e9e3db2005-06-23 22:04:20 -07003472 struct nfs4_stateowner *open_sop = NULL;
Neil Brownb59e3c02005-09-13 01:25:38 -07003473 struct nfs4_stateowner *lock_sop = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003474 struct nfs4_stateid *lock_stp;
3475 struct file *filp;
3476 struct file_lock file_lock;
Andy Adamson8dc7c312006-03-20 13:44:26 -05003477 struct file_lock conflock;
Al Virob37ad282006-10-19 23:28:59 -07003478 __be32 status = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003479 unsigned int strhashval;
Marc Eshel150b3932007-01-18 16:15:35 -05003480 unsigned int cmd;
Al Virob8dd7b92006-10-19 23:29:01 -07003481 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003482
3483 dprintk("NFSD: nfsd4_lock: start=%Ld length=%Ld\n",
3484 (long long) lock->lk_offset,
3485 (long long) lock->lk_length);
3486
Linus Torvalds1da177e2005-04-16 15:20:36 -07003487 if (check_lock_length(lock->lk_offset, lock->lk_length))
3488 return nfserr_inval;
3489
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003490 if ((status = fh_verify(rqstp, &cstate->current_fh,
Miklos Szeredi8837abc2008-06-16 13:20:29 +02003491 S_IFREG, NFSD_MAY_LOCK))) {
Andy Adamsona6f6ef22006-01-18 17:43:17 -08003492 dprintk("NFSD: nfsd4_lock: permission denied!\n");
3493 return status;
3494 }
3495
Linus Torvalds1da177e2005-04-16 15:20:36 -07003496 nfs4_lock_state();
3497
3498 if (lock->lk_is_new) {
NeilBrown893f8772005-07-07 17:59:17 -07003499 /*
3500 * Client indicates that this is a new lockowner.
3501 * Use open owner and open stateid to create lock owner and
3502 * lock stateid.
3503 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003504 struct nfs4_stateid *open_stp = NULL;
3505 struct nfs4_file *fp;
3506
3507 status = nfserr_stale_clientid;
Andy Adamson60adfc52009-04-03 08:28:50 +03003508 if (!nfsd4_has_session(cstate) &&
3509 STALE_CLIENTID(&lock->lk_new_clientid))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003510 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003511
Linus Torvalds1da177e2005-04-16 15:20:36 -07003512 /* validate and update open stateid and open seqid */
Benny Halevydd453df2009-04-03 08:28:41 +03003513 status = nfs4_preprocess_seqid_op(cstate,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003514 lock->lk_new_open_seqid,
3515 &lock->lk_new_open_stateid,
J. Bruce Fieldsf3362732008-01-26 14:58:45 -05003516 OPEN_STATE,
J. Bruce Fields3a655882006-01-18 17:43:19 -08003517 &lock->lk_replay_owner, &open_stp,
Neil Brownb59e3c02005-09-13 01:25:38 -07003518 lock);
NeilBrown37515172005-07-07 17:59:16 -07003519 if (status)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003520 goto out;
J. Bruce Fields3a655882006-01-18 17:43:19 -08003521 open_sop = lock->lk_replay_owner;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003522 /* create lockowner and lock stateid */
3523 fp = open_stp->st_file;
3524 strhashval = lock_ownerstr_hashval(fp->fi_inode,
3525 open_sop->so_client->cl_clientid.cl_id,
3526 &lock->v.new.owner);
NeilBrown3e9e3db2005-06-23 22:04:20 -07003527 /* XXX: Do we need to check for duplicate stateowners on
3528 * the same file, or should they just be allowed (and
3529 * create new stateids)? */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003530 status = nfserr_resource;
Neil Brownb59e3c02005-09-13 01:25:38 -07003531 lock_sop = alloc_init_lock_stateowner(strhashval,
3532 open_sop->so_client, open_stp, lock);
3533 if (lock_sop == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003534 goto out;
Neil Brownb59e3c02005-09-13 01:25:38 -07003535 lock_stp = alloc_init_lock_stateid(lock_sop, fp, open_stp);
J. Bruce Fields8a280512006-01-18 17:43:18 -08003536 if (lock_stp == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003537 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003538 } else {
3539 /* lock (lock owner + lock stateid) already exists */
Benny Halevydd453df2009-04-03 08:28:41 +03003540 status = nfs4_preprocess_seqid_op(cstate,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003541 lock->lk_old_lock_seqid,
3542 &lock->lk_old_lock_stateid,
J. Bruce Fieldsf3362732008-01-26 14:58:45 -05003543 LOCK_STATE,
J. Bruce Fields3a655882006-01-18 17:43:19 -08003544 &lock->lk_replay_owner, &lock_stp, lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003545 if (status)
3546 goto out;
J. Bruce Fields3a655882006-01-18 17:43:19 -08003547 lock_sop = lock->lk_replay_owner;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003548 }
J. Bruce Fields3a655882006-01-18 17:43:19 -08003549 /* lock->lk_replay_owner and lock_stp have been created or found */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003550 filp = lock_stp->st_vfs_file;
3551
NeilBrown0dd395d2005-07-07 17:59:15 -07003552 status = nfserr_grace;
J. Bruce Fieldsaf558e32007-09-06 12:34:25 -04003553 if (locks_in_grace() && !lock->lk_reclaim)
NeilBrown0dd395d2005-07-07 17:59:15 -07003554 goto out;
3555 status = nfserr_no_grace;
J. Bruce Fieldsaf558e32007-09-06 12:34:25 -04003556 if (!locks_in_grace() && lock->lk_reclaim)
NeilBrown0dd395d2005-07-07 17:59:15 -07003557 goto out;
3558
Linus Torvalds1da177e2005-04-16 15:20:36 -07003559 locks_init_lock(&file_lock);
3560 switch (lock->lk_type) {
3561 case NFS4_READ_LT:
3562 case NFS4_READW_LT:
3563 file_lock.fl_type = F_RDLCK;
Marc Eshel150b3932007-01-18 16:15:35 -05003564 cmd = F_SETLK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003565 break;
3566 case NFS4_WRITE_LT:
3567 case NFS4_WRITEW_LT:
3568 file_lock.fl_type = F_WRLCK;
Marc Eshel150b3932007-01-18 16:15:35 -05003569 cmd = F_SETLK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003570 break;
3571 default:
3572 status = nfserr_inval;
3573 goto out;
3574 }
Neil Brownb59e3c02005-09-13 01:25:38 -07003575 file_lock.fl_owner = (fl_owner_t)lock_sop;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003576 file_lock.fl_pid = current->tgid;
3577 file_lock.fl_file = filp;
3578 file_lock.fl_flags = FL_POSIX;
NeilBrownd5b90262006-04-10 22:55:22 -07003579 file_lock.fl_lmops = &nfsd_posix_mng_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003580
3581 file_lock.fl_start = lock->lk_offset;
Benny Halevy87df4de2008-12-15 19:42:03 +02003582 file_lock.fl_end = last_byte_offset(lock->lk_offset, lock->lk_length);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003583 nfs4_transform_lock_offset(&file_lock);
3584
3585 /*
3586 * Try to lock the file in the VFS.
3587 * Note: locks.c uses the BKL to protect the inode's lock list.
3588 */
3589
Marc Eshelfd85b812006-11-28 16:26:41 -05003590 err = vfs_lock_file(filp, cmd, &file_lock, &conflock);
Al Virob8dd7b92006-10-19 23:29:01 -07003591 switch (-err) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003592 case 0: /* success! */
3593 update_stateid(&lock_stp->st_stateid);
3594 memcpy(&lock->lk_resp_stateid, &lock_stp->st_stateid,
3595 sizeof(stateid_t));
Al Virob8dd7b92006-10-19 23:29:01 -07003596 status = 0;
Andy Adamsoneb76b3f2006-03-26 01:37:26 -08003597 break;
3598 case (EAGAIN): /* conflock holds conflicting lock */
3599 status = nfserr_denied;
3600 dprintk("NFSD: nfsd4_lock: conflicting lock found!\n");
3601 nfs4_set_lock_denied(&conflock, &lock->lk_denied);
3602 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003603 case (EDEADLK):
3604 status = nfserr_deadlock;
Andy Adamsoneb76b3f2006-03-26 01:37:26 -08003605 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003606 default:
Marc Eshelfd85b812006-11-28 16:26:41 -05003607 dprintk("NFSD: nfsd4_lock: vfs_lock_file() failed! status %d\n",err);
Andy Adamsoneb76b3f2006-03-26 01:37:26 -08003608 status = nfserr_resource;
3609 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003610 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003611out:
J. Bruce Fields8a280512006-01-18 17:43:18 -08003612 if (status && lock->lk_is_new && lock_sop)
J. Bruce Fieldsf044ff82009-01-11 15:24:04 -05003613 release_lockowner(lock_sop);
J. Bruce Fields3a655882006-01-18 17:43:19 -08003614 if (lock->lk_replay_owner) {
3615 nfs4_get_stateowner(lock->lk_replay_owner);
J.Bruce Fieldsa4f1706a92006-12-13 00:35:28 -08003616 cstate->replay_owner = lock->lk_replay_owner;
Neil Brownf2327d92005-09-13 01:25:37 -07003617 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003618 nfs4_unlock_state();
3619 return status;
3620}
3621
3622/*
J. Bruce Fields55ef1272008-12-20 11:58:38 -08003623 * The NFSv4 spec allows a client to do a LOCKT without holding an OPEN,
3624 * so we do a temporary open here just to get an open file to pass to
3625 * vfs_test_lock. (Arguably perhaps test_lock should be done with an
3626 * inode operation.)
3627 */
3628static int nfsd_test_lock(struct svc_rqst *rqstp, struct svc_fh *fhp, struct file_lock *lock)
3629{
3630 struct file *file;
3631 int err;
3632
3633 err = nfsd_open(rqstp, fhp, S_IFREG, NFSD_MAY_READ, &file);
3634 if (err)
3635 return err;
3636 err = vfs_test_lock(file, lock);
3637 nfsd_close(file);
3638 return err;
3639}
3640
3641/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07003642 * LOCKT operation
3643 */
Al Virob37ad282006-10-19 23:28:59 -07003644__be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003645nfsd4_lockt(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
3646 struct nfsd4_lockt *lockt)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003647{
3648 struct inode *inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003649 struct file_lock file_lock;
Marc Eshelfd85b812006-11-28 16:26:41 -05003650 int error;
Al Virob37ad282006-10-19 23:28:59 -07003651 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003652
J. Bruce Fieldsaf558e32007-09-06 12:34:25 -04003653 if (locks_in_grace())
Linus Torvalds1da177e2005-04-16 15:20:36 -07003654 return nfserr_grace;
3655
3656 if (check_lock_length(lockt->lt_offset, lockt->lt_length))
3657 return nfserr_inval;
3658
3659 lockt->lt_stateowner = NULL;
3660 nfs4_lock_state();
3661
3662 status = nfserr_stale_clientid;
Andy Adamson60adfc52009-04-03 08:28:50 +03003663 if (!nfsd4_has_session(cstate) && STALE_CLIENTID(&lockt->lt_clientid))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003664 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003665
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003666 if ((status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0))) {
Neil Brown849823c2005-09-13 01:25:36 -07003667 dprintk("NFSD: nfsd4_lockt: fh_verify() failed!\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003668 if (status == nfserr_symlink)
3669 status = nfserr_inval;
3670 goto out;
3671 }
3672
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003673 inode = cstate->current_fh.fh_dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003674 locks_init_lock(&file_lock);
3675 switch (lockt->lt_type) {
3676 case NFS4_READ_LT:
3677 case NFS4_READW_LT:
3678 file_lock.fl_type = F_RDLCK;
3679 break;
3680 case NFS4_WRITE_LT:
3681 case NFS4_WRITEW_LT:
3682 file_lock.fl_type = F_WRLCK;
3683 break;
3684 default:
J. Bruce Fields2fdada02007-07-27 16:10:37 -04003685 dprintk("NFSD: nfs4_lockt: bad lock type!\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003686 status = nfserr_inval;
3687 goto out;
3688 }
3689
3690 lockt->lt_stateowner = find_lockstateowner_str(inode,
3691 &lockt->lt_clientid, &lockt->lt_owner);
3692 if (lockt->lt_stateowner)
3693 file_lock.fl_owner = (fl_owner_t)lockt->lt_stateowner;
3694 file_lock.fl_pid = current->tgid;
3695 file_lock.fl_flags = FL_POSIX;
3696
3697 file_lock.fl_start = lockt->lt_offset;
Benny Halevy87df4de2008-12-15 19:42:03 +02003698 file_lock.fl_end = last_byte_offset(lockt->lt_offset, lockt->lt_length);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003699
3700 nfs4_transform_lock_offset(&file_lock);
3701
Linus Torvalds1da177e2005-04-16 15:20:36 -07003702 status = nfs_ok;
J. Bruce Fields55ef1272008-12-20 11:58:38 -08003703 error = nfsd_test_lock(rqstp, &cstate->current_fh, &file_lock);
Marc Eshelfd85b812006-11-28 16:26:41 -05003704 if (error) {
3705 status = nfserrno(error);
3706 goto out;
3707 }
Marc Eshel9d6a8c52007-02-21 00:55:18 -05003708 if (file_lock.fl_type != F_UNLCK) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003709 status = nfserr_denied;
Marc Eshel9d6a8c52007-02-21 00:55:18 -05003710 nfs4_set_lock_denied(&file_lock, &lockt->lt_denied);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003711 }
3712out:
3713 nfs4_unlock_state();
3714 return status;
3715}
3716
Al Virob37ad282006-10-19 23:28:59 -07003717__be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003718nfsd4_locku(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
J.Bruce Fieldsa4f1706a92006-12-13 00:35:28 -08003719 struct nfsd4_locku *locku)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003720{
3721 struct nfs4_stateid *stp;
3722 struct file *filp = NULL;
3723 struct file_lock file_lock;
Al Virob37ad282006-10-19 23:28:59 -07003724 __be32 status;
Al Virob8dd7b92006-10-19 23:29:01 -07003725 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003726
3727 dprintk("NFSD: nfsd4_locku: start=%Ld length=%Ld\n",
3728 (long long) locku->lu_offset,
3729 (long long) locku->lu_length);
3730
3731 if (check_lock_length(locku->lu_offset, locku->lu_length))
3732 return nfserr_inval;
3733
3734 nfs4_lock_state();
3735
Benny Halevydd453df2009-04-03 08:28:41 +03003736 if ((status = nfs4_preprocess_seqid_op(cstate,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003737 locku->lu_seqid,
3738 &locku->lu_stateid,
J. Bruce Fieldsf3362732008-01-26 14:58:45 -05003739 LOCK_STATE,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003740 &locku->lu_stateowner, &stp, NULL)))
3741 goto out;
3742
3743 filp = stp->st_vfs_file;
3744 BUG_ON(!filp);
3745 locks_init_lock(&file_lock);
3746 file_lock.fl_type = F_UNLCK;
3747 file_lock.fl_owner = (fl_owner_t) locku->lu_stateowner;
3748 file_lock.fl_pid = current->tgid;
3749 file_lock.fl_file = filp;
3750 file_lock.fl_flags = FL_POSIX;
NeilBrownd5b90262006-04-10 22:55:22 -07003751 file_lock.fl_lmops = &nfsd_posix_mng_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003752 file_lock.fl_start = locku->lu_offset;
3753
Benny Halevy87df4de2008-12-15 19:42:03 +02003754 file_lock.fl_end = last_byte_offset(locku->lu_offset, locku->lu_length);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003755 nfs4_transform_lock_offset(&file_lock);
3756
3757 /*
3758 * Try to unlock the file in the VFS.
3759 */
Marc Eshelfd85b812006-11-28 16:26:41 -05003760 err = vfs_lock_file(filp, F_SETLK, &file_lock, NULL);
Al Virob8dd7b92006-10-19 23:29:01 -07003761 if (err) {
Marc Eshelfd85b812006-11-28 16:26:41 -05003762 dprintk("NFSD: nfs4_locku: vfs_lock_file failed!\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003763 goto out_nfserr;
3764 }
3765 /*
3766 * OK, unlock succeeded; the only thing left to do is update the stateid.
3767 */
3768 update_stateid(&stp->st_stateid);
3769 memcpy(&locku->lu_stateid, &stp->st_stateid, sizeof(stateid_t));
3770
3771out:
Neil Brownf2327d92005-09-13 01:25:37 -07003772 if (locku->lu_stateowner) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003773 nfs4_get_stateowner(locku->lu_stateowner);
J.Bruce Fieldsa4f1706a92006-12-13 00:35:28 -08003774 cstate->replay_owner = locku->lu_stateowner;
Neil Brownf2327d92005-09-13 01:25:37 -07003775 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003776 nfs4_unlock_state();
3777 return status;
3778
3779out_nfserr:
Al Virob8dd7b92006-10-19 23:29:01 -07003780 status = nfserrno(err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003781 goto out;
3782}
3783
3784/*
3785 * returns
3786 * 1: locks held by lockowner
3787 * 0: no locks held by lockowner
3788 */
3789static int
3790check_for_locks(struct file *filp, struct nfs4_stateowner *lowner)
3791{
3792 struct file_lock **flpp;
Josef "Jeff" Sipek7eaa36e2006-12-08 02:36:41 -08003793 struct inode *inode = filp->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003794 int status = 0;
3795
3796 lock_kernel();
3797 for (flpp = &inode->i_flock; *flpp != NULL; flpp = &(*flpp)->fl_next) {
J. Bruce Fields796dadf2006-01-18 17:43:22 -08003798 if ((*flpp)->fl_owner == (fl_owner_t)lowner) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003799 status = 1;
3800 goto out;
J. Bruce Fields796dadf2006-01-18 17:43:22 -08003801 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003802 }
3803out:
3804 unlock_kernel();
3805 return status;
3806}
3807
Al Virob37ad282006-10-19 23:28:59 -07003808__be32
J.Bruce Fieldsb5914802006-12-13 00:35:38 -08003809nfsd4_release_lockowner(struct svc_rqst *rqstp,
3810 struct nfsd4_compound_state *cstate,
3811 struct nfsd4_release_lockowner *rlockowner)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003812{
3813 clientid_t *clid = &rlockowner->rl_clientid;
NeilBrown3e9e3db2005-06-23 22:04:20 -07003814 struct nfs4_stateowner *sop;
3815 struct nfs4_stateid *stp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003816 struct xdr_netobj *owner = &rlockowner->rl_owner;
NeilBrown3e9e3db2005-06-23 22:04:20 -07003817 struct list_head matches;
3818 int i;
Al Virob37ad282006-10-19 23:28:59 -07003819 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003820
3821 dprintk("nfsd4_release_lockowner clientid: (%08x/%08x):\n",
3822 clid->cl_boot, clid->cl_id);
3823
3824 /* XXX check for lease expiration */
3825
3826 status = nfserr_stale_clientid;
Neil Brown849823c2005-09-13 01:25:36 -07003827 if (STALE_CLIENTID(clid))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003828 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003829
3830 nfs4_lock_state();
3831
NeilBrown3e9e3db2005-06-23 22:04:20 -07003832 status = nfserr_locks_held;
3833 /* XXX: we're doing a linear search through all the lockowners.
3834 * Yipes! For now we'll just hope clients aren't really using
3835 * release_lockowner much, but eventually we have to fix these
3836 * data structures. */
3837 INIT_LIST_HEAD(&matches);
3838 for (i = 0; i < LOCK_HASH_SIZE; i++) {
3839 list_for_each_entry(sop, &lock_ownerid_hashtbl[i], so_idhash) {
J. Bruce Fields599e0a22007-07-26 17:04:54 -04003840 if (!same_owner_str(sop, owner, clid))
NeilBrown3e9e3db2005-06-23 22:04:20 -07003841 continue;
3842 list_for_each_entry(stp, &sop->so_stateids,
3843 st_perstateowner) {
3844 if (check_for_locks(stp->st_vfs_file, sop))
3845 goto out;
3846 /* Note: so_perclient unused for lockowners,
3847 * so it's OK to fool with here. */
3848 list_add(&sop->so_perclient, &matches);
3849 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003850 }
NeilBrown3e9e3db2005-06-23 22:04:20 -07003851 }
3852 /* Clients probably won't expect us to return with some (but not all)
3853 * of the lockowner state released; so don't release any until all
3854 * have been checked. */
3855 status = nfs_ok;
NeilBrown0fa822e2005-07-07 17:59:14 -07003856 while (!list_empty(&matches)) {
3857 sop = list_entry(matches.next, struct nfs4_stateowner,
3858 so_perclient);
3859 /* unhash_stateowner deletes so_perclient only
3860 * for openowners. */
3861 list_del(&sop->so_perclient);
J. Bruce Fieldsf044ff82009-01-11 15:24:04 -05003862 release_lockowner(sop);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003863 }
3864out:
3865 nfs4_unlock_state();
3866 return status;
3867}
3868
3869static inline struct nfs4_client_reclaim *
NeilBrowna55370a2005-06-23 22:03:52 -07003870alloc_reclaim(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003871{
NeilBrowna55370a2005-06-23 22:03:52 -07003872 return kmalloc(sizeof(struct nfs4_client_reclaim), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003873}
3874
NeilBrownc7b9a452005-06-23 22:04:30 -07003875int
Andy Adamsona1bcecd2009-04-03 08:28:05 +03003876nfs4_has_reclaimed_state(const char *name, bool use_exchange_id)
NeilBrownc7b9a452005-06-23 22:04:30 -07003877{
3878 unsigned int strhashval = clientstr_hashval(name);
3879 struct nfs4_client *clp;
3880
Andy Adamsona1bcecd2009-04-03 08:28:05 +03003881 clp = find_confirmed_client_by_str(name, strhashval, use_exchange_id);
NeilBrownc7b9a452005-06-23 22:04:30 -07003882 return clp ? 1 : 0;
3883}
3884
Linus Torvalds1da177e2005-04-16 15:20:36 -07003885/*
3886 * failure => all reset bets are off, nfserr_no_grace...
3887 */
NeilBrown190e4fb2005-06-23 22:04:25 -07003888int
3889nfs4_client_to_reclaim(const char *name)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003890{
3891 unsigned int strhashval;
3892 struct nfs4_client_reclaim *crp = NULL;
3893
NeilBrowna55370a2005-06-23 22:03:52 -07003894 dprintk("NFSD nfs4_client_to_reclaim NAME: %.*s\n", HEXDIR_LEN, name);
3895 crp = alloc_reclaim();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003896 if (!crp)
3897 return 0;
NeilBrowna55370a2005-06-23 22:03:52 -07003898 strhashval = clientstr_hashval(name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003899 INIT_LIST_HEAD(&crp->cr_strhash);
3900 list_add(&crp->cr_strhash, &reclaim_str_hashtbl[strhashval]);
NeilBrowna55370a2005-06-23 22:03:52 -07003901 memcpy(crp->cr_recdir, name, HEXDIR_LEN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003902 reclaim_str_hashtbl_size++;
3903 return 1;
3904}
3905
3906static void
3907nfs4_release_reclaim(void)
3908{
3909 struct nfs4_client_reclaim *crp = NULL;
3910 int i;
3911
Linus Torvalds1da177e2005-04-16 15:20:36 -07003912 for (i = 0; i < CLIENT_HASH_SIZE; i++) {
3913 while (!list_empty(&reclaim_str_hashtbl[i])) {
3914 crp = list_entry(reclaim_str_hashtbl[i].next,
3915 struct nfs4_client_reclaim, cr_strhash);
3916 list_del(&crp->cr_strhash);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003917 kfree(crp);
3918 reclaim_str_hashtbl_size--;
3919 }
3920 }
3921 BUG_ON(reclaim_str_hashtbl_size);
3922}
3923
3924/*
3925 * called from OPEN, CLAIM_PREVIOUS with a new clientid. */
NeilBrownfd39ca92005-06-23 22:04:03 -07003926static struct nfs4_client_reclaim *
Linus Torvalds1da177e2005-04-16 15:20:36 -07003927nfs4_find_reclaim_client(clientid_t *clid)
3928{
3929 unsigned int strhashval;
3930 struct nfs4_client *clp;
3931 struct nfs4_client_reclaim *crp = NULL;
3932
3933
3934 /* find clientid in conf_id_hashtbl */
3935 clp = find_confirmed_client(clid);
3936 if (clp == NULL)
3937 return NULL;
3938
NeilBrowna55370a2005-06-23 22:03:52 -07003939 dprintk("NFSD: nfs4_find_reclaim_client for %.*s with recdir %s\n",
3940 clp->cl_name.len, clp->cl_name.data,
3941 clp->cl_recdir);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003942
3943 /* find clp->cl_name in reclaim_str_hashtbl */
NeilBrowna55370a2005-06-23 22:03:52 -07003944 strhashval = clientstr_hashval(clp->cl_recdir);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003945 list_for_each_entry(crp, &reclaim_str_hashtbl[strhashval], cr_strhash) {
NeilBrowna55370a2005-06-23 22:03:52 -07003946 if (same_name(crp->cr_recdir, clp->cl_recdir)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003947 return crp;
3948 }
3949 }
3950 return NULL;
3951}
3952
3953/*
3954* Called from OPEN. Look for clientid in reclaim list.
3955*/
Al Virob37ad282006-10-19 23:28:59 -07003956__be32
Linus Torvalds1da177e2005-04-16 15:20:36 -07003957nfs4_check_open_reclaim(clientid_t *clid)
3958{
NeilBrowndfc83562005-06-23 22:03:16 -07003959 return nfs4_find_reclaim_client(clid) ? nfs_ok : nfserr_reclaim_bad;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003960}
3961
NeilBrownac4d8ff22005-06-23 22:03:30 -07003962/* initialization to perform at module load time: */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003963
J. Bruce Fieldse8ff2a82007-08-01 15:30:59 -04003964int
NeilBrownac4d8ff22005-06-23 22:03:30 -07003965nfs4_state_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003966{
J. Bruce Fieldse8ff2a82007-08-01 15:30:59 -04003967 int i, status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003968
J. Bruce Fieldse8ff2a82007-08-01 15:30:59 -04003969 status = nfsd4_init_slabs();
3970 if (status)
3971 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003972 for (i = 0; i < CLIENT_HASH_SIZE; i++) {
3973 INIT_LIST_HEAD(&conf_id_hashtbl[i]);
3974 INIT_LIST_HEAD(&conf_str_hashtbl[i]);
3975 INIT_LIST_HEAD(&unconf_str_hashtbl[i]);
3976 INIT_LIST_HEAD(&unconf_id_hashtbl[i]);
Wang Chen02cb2852009-04-24 15:41:57 +08003977 INIT_LIST_HEAD(&reclaim_str_hashtbl[i]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003978 }
Marc Eshel5282fd72009-04-03 08:27:52 +03003979 for (i = 0; i < SESSION_HASH_SIZE; i++)
3980 INIT_LIST_HEAD(&sessionid_hashtbl[i]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003981 for (i = 0; i < FILE_HASH_SIZE; i++) {
3982 INIT_LIST_HEAD(&file_hashtbl[i]);
3983 }
3984 for (i = 0; i < OWNER_HASH_SIZE; i++) {
3985 INIT_LIST_HEAD(&ownerstr_hashtbl[i]);
3986 INIT_LIST_HEAD(&ownerid_hashtbl[i]);
3987 }
3988 for (i = 0; i < STATEID_HASH_SIZE; i++) {
3989 INIT_LIST_HEAD(&stateid_hashtbl[i]);
3990 INIT_LIST_HEAD(&lockstateid_hashtbl[i]);
3991 }
3992 for (i = 0; i < LOCK_HASH_SIZE; i++) {
3993 INIT_LIST_HEAD(&lock_ownerid_hashtbl[i]);
3994 INIT_LIST_HEAD(&lock_ownerstr_hashtbl[i]);
3995 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003996 memset(&onestateid, ~0, sizeof(stateid_t));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003997 INIT_LIST_HEAD(&close_lru);
3998 INIT_LIST_HEAD(&client_lru);
3999 INIT_LIST_HEAD(&del_recall_lru);
NeilBrownac4d8ff22005-06-23 22:03:30 -07004000 reclaim_str_hashtbl_size = 0;
J. Bruce Fieldse8ff2a82007-08-01 15:30:59 -04004001 return 0;
NeilBrownac4d8ff22005-06-23 22:03:30 -07004002}
4003
NeilBrown190e4fb2005-06-23 22:04:25 -07004004static void
4005nfsd4_load_reboot_recovery_data(void)
4006{
4007 int status;
4008
NeilBrown0964a3d2005-06-23 22:04:32 -07004009 nfs4_lock_state();
4010 nfsd4_init_recdir(user_recovery_dirname);
NeilBrown190e4fb2005-06-23 22:04:25 -07004011 status = nfsd4_recdir_load();
NeilBrown0964a3d2005-06-23 22:04:32 -07004012 nfs4_unlock_state();
NeilBrown190e4fb2005-06-23 22:04:25 -07004013 if (status)
4014 printk("NFSD: Failure reading reboot recovery data\n");
4015}
4016
Meelap Shahc2f1a552007-07-17 04:04:39 -07004017/*
4018 * Since the lifetime of a delegation isn't limited to that of an open, a
4019 * client may quite reasonably hang on to a delegation as long as it has
4020 * the inode cached. This becomes an obvious problem the first time a
4021 * client's inode cache approaches the size of the server's total memory.
4022 *
4023 * For now we avoid this problem by imposing a hard limit on the number
4024 * of delegations, which varies according to the server's memory size.
4025 */
4026static void
4027set_max_delegations(void)
4028{
4029 /*
4030 * Allow at most 4 delegations per megabyte of RAM. Quick
4031 * estimates suggest that in the worst case (where every delegation
4032 * is for a different inode), a delegation could take about 1.5K,
4033 * giving a worst case usage of about 6% of memory.
4034 */
4035 max_delegations = nr_free_buffer_pages() >> (20 - 2 - PAGE_SHIFT);
4036}
4037
NeilBrownac4d8ff22005-06-23 22:03:30 -07004038/* initialization to perform when the nfsd service is started: */
4039
J. Bruce Fields29ab23c2009-09-15 15:56:50 -04004040static int
NeilBrownac4d8ff22005-06-23 22:03:30 -07004041__nfs4_state_start(void)
4042{
J. Bruce Fieldsb5a1a812010-03-03 14:52:55 -05004043 int ret;
4044
Linus Torvalds1da177e2005-04-16 15:20:36 -07004045 boot_time = get_seconds();
J. Bruce Fieldsaf558e32007-09-06 12:34:25 -04004046 locks_start_grace(&nfsd4_manager);
Marc Eshel9a8db972007-07-17 04:04:35 -07004047 printk(KERN_INFO "NFSD: starting %ld-second grace period\n",
J. Bruce Fieldse46b4982010-03-01 19:21:21 -05004048 nfsd4_grace);
J. Bruce Fieldsb5a1a812010-03-03 14:52:55 -05004049 ret = set_callback_cred();
4050 if (ret)
4051 return -ENOMEM;
NeilBrown58da2822005-06-23 22:03:19 -07004052 laundry_wq = create_singlethread_workqueue("nfsd4");
J. Bruce Fields29ab23c2009-09-15 15:56:50 -04004053 if (laundry_wq == NULL)
4054 return -ENOMEM;
J. Bruce Fieldsb5a1a812010-03-03 14:52:55 -05004055 ret = nfsd4_create_callback_queue();
4056 if (ret)
4057 goto out_free_laundry;
J. Bruce Fieldse46b4982010-03-01 19:21:21 -05004058 queue_delayed_work(laundry_wq, &laundromat_work, nfsd4_grace * HZ);
Meelap Shahc2f1a552007-07-17 04:04:39 -07004059 set_max_delegations();
J. Bruce Fieldsb5a1a812010-03-03 14:52:55 -05004060 return 0;
4061out_free_laundry:
4062 destroy_workqueue(laundry_wq);
4063 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004064}
4065
J. Bruce Fields29ab23c2009-09-15 15:56:50 -04004066int
NeilBrown76a35502005-06-23 22:03:26 -07004067nfs4_state_start(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004068{
J. Bruce Fields29ab23c2009-09-15 15:56:50 -04004069 int ret;
4070
Linus Torvalds1da177e2005-04-16 15:20:36 -07004071 if (nfs4_init)
J. Bruce Fields29ab23c2009-09-15 15:56:50 -04004072 return 0;
NeilBrown190e4fb2005-06-23 22:04:25 -07004073 nfsd4_load_reboot_recovery_data();
J. Bruce Fields29ab23c2009-09-15 15:56:50 -04004074 ret = __nfs4_state_start();
4075 if (ret)
4076 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004077 nfs4_init = 1;
J. Bruce Fields29ab23c2009-09-15 15:56:50 -04004078 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004079}
4080
Linus Torvalds1da177e2005-04-16 15:20:36 -07004081static void
4082__nfs4_state_shutdown(void)
4083{
4084 int i;
4085 struct nfs4_client *clp = NULL;
4086 struct nfs4_delegation *dp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004087 struct list_head *pos, *next, reaplist;
4088
Linus Torvalds1da177e2005-04-16 15:20:36 -07004089 for (i = 0; i < CLIENT_HASH_SIZE; i++) {
4090 while (!list_empty(&conf_id_hashtbl[i])) {
4091 clp = list_entry(conf_id_hashtbl[i].next, struct nfs4_client, cl_idhash);
4092 expire_client(clp);
4093 }
4094 while (!list_empty(&unconf_str_hashtbl[i])) {
4095 clp = list_entry(unconf_str_hashtbl[i].next, struct nfs4_client, cl_strhash);
4096 expire_client(clp);
4097 }
4098 }
4099 INIT_LIST_HEAD(&reaplist);
4100 spin_lock(&recall_lock);
4101 list_for_each_safe(pos, next, &del_recall_lru) {
4102 dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
4103 list_move(&dp->dl_recall_lru, &reaplist);
4104 }
4105 spin_unlock(&recall_lock);
4106 list_for_each_safe(pos, next, &reaplist) {
4107 dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
4108 list_del_init(&dp->dl_recall_lru);
4109 unhash_delegation(dp);
4110 }
4111
NeilBrown190e4fb2005-06-23 22:04:25 -07004112 nfsd4_shutdown_recdir();
Linus Torvalds1da177e2005-04-16 15:20:36 -07004113 nfs4_init = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004114}
4115
4116void
4117nfs4_state_shutdown(void)
4118{
NeilBrown5e8d5c22006-04-10 22:55:37 -07004119 cancel_rearming_delayed_workqueue(laundry_wq, &laundromat_work);
4120 destroy_workqueue(laundry_wq);
J. Bruce Fields2c5e7612008-11-20 14:36:17 -06004121 locks_end_grace(&nfsd4_manager);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004122 nfs4_lock_state();
4123 nfs4_release_reclaim();
4124 __nfs4_state_shutdown();
J. Bruce Fieldsb5a1a812010-03-03 14:52:55 -05004125 nfsd4_destroy_callback_queue();
Linus Torvalds1da177e2005-04-16 15:20:36 -07004126 nfs4_unlock_state();
4127}
4128
Jeff Layton3dd98a32008-06-10 08:40:36 -04004129/*
4130 * user_recovery_dirname is protected by the nfsd_mutex since it's only
4131 * accessed when nfsd is starting.
4132 */
NeilBrown0964a3d2005-06-23 22:04:32 -07004133static void
4134nfs4_set_recdir(char *recdir)
4135{
NeilBrown0964a3d2005-06-23 22:04:32 -07004136 strcpy(user_recovery_dirname, recdir);
NeilBrown0964a3d2005-06-23 22:04:32 -07004137}
4138
4139/*
4140 * Change the NFSv4 recovery directory to recdir.
4141 */
4142int
4143nfs4_reset_recoverydir(char *recdir)
4144{
4145 int status;
Al Viroa63bb992008-08-02 01:03:36 -04004146 struct path path;
NeilBrown0964a3d2005-06-23 22:04:32 -07004147
Al Viroa63bb992008-08-02 01:03:36 -04004148 status = kern_path(recdir, LOOKUP_FOLLOW, &path);
NeilBrown0964a3d2005-06-23 22:04:32 -07004149 if (status)
4150 return status;
4151 status = -ENOTDIR;
Al Viroa63bb992008-08-02 01:03:36 -04004152 if (S_ISDIR(path.dentry->d_inode->i_mode)) {
NeilBrown0964a3d2005-06-23 22:04:32 -07004153 nfs4_set_recdir(recdir);
4154 status = 0;
4155 }
Al Viroa63bb992008-08-02 01:03:36 -04004156 path_put(&path);
NeilBrown0964a3d2005-06-23 22:04:32 -07004157 return status;
4158}
4159
Jeff Layton3dd98a32008-06-10 08:40:36 -04004160char *
4161nfs4_recoverydir(void)
4162{
4163 return user_recovery_dirname;
4164}