blob: 2153f9bdbebdcb3cb094a76c73b9948815b30e2d [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2* linux/fs/nfsd/nfs4state.c
3*
4* Copyright (c) 2001 The Regents of the University of Michigan.
5* All rights reserved.
6*
7* Kendrick Smith <kmsmith@umich.edu>
8* Andy Adamson <kandros@umich.edu>
9*
10* Redistribution and use in source and binary forms, with or without
11* modification, are permitted provided that the following conditions
12* are met:
13*
14* 1. Redistributions of source code must retain the above copyright
15* notice, this list of conditions and the following disclaimer.
16* 2. Redistributions in binary form must reproduce the above copyright
17* notice, this list of conditions and the following disclaimer in the
18* documentation and/or other materials provided with the distribution.
19* 3. Neither the name of the University nor the names of its
20* contributors may be used to endorse or promote products derived
21* from this software without specific prior written permission.
22*
23* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
24* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
25* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
26* DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
27* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
28* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
29* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
30* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
31* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
32* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
33* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
34*
35*/
36
37#include <linux/param.h>
38#include <linux/major.h>
39#include <linux/slab.h>
40
41#include <linux/sunrpc/svc.h>
42#include <linux/nfsd/nfsd.h>
43#include <linux/nfsd/cache.h>
Dave Hansenaceaf782008-02-15 14:37:31 -080044#include <linux/file.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070045#include <linux/mount.h>
46#include <linux/workqueue.h>
47#include <linux/smp_lock.h>
48#include <linux/kthread.h>
49#include <linux/nfs4.h>
50#include <linux/nfsd/state.h>
51#include <linux/nfsd/xdr4.h>
NeilBrown0964a3d2005-06-23 22:04:32 -070052#include <linux/namei.h>
Meelap Shahc2f1a552007-07-17 04:04:39 -070053#include <linux/swap.h>
Ingo Molnar353ab6e2006-03-26 01:37:12 -080054#include <linux/mutex.h>
Marc Eshelfd85b812006-11-28 16:26:41 -050055#include <linux/lockd/bind.h>
Marc Eshel9a8db972007-07-17 04:04:35 -070056#include <linux/module.h>
Olga Kornievskaia68e76ad2008-12-23 16:17:15 -050057#include <linux/sunrpc/svcauth_gss.h>
Jeff Layton363168b2009-08-14 12:57:56 -040058#include <linux/sunrpc/clnt.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070059
60#define NFSDDBG_FACILITY NFSDDBG_PROC
61
62/* Globals */
63static time_t lease_time = 90; /* default lease time */
NeilBrownd99a05a2005-06-23 22:03:21 -070064static time_t user_lease_time = 90;
NeilBrownfd39ca92005-06-23 22:04:03 -070065static time_t boot_time;
Linus Torvalds1da177e2005-04-16 15:20:36 -070066static u32 current_ownerid = 1;
67static u32 current_fileid = 1;
68static u32 current_delegid = 1;
69static u32 nfs4_init;
NeilBrownfd39ca92005-06-23 22:04:03 -070070static stateid_t zerostateid; /* bits all 0 */
71static stateid_t onestateid; /* bits all 1 */
Andy Adamsonec6b5d72009-04-03 08:28:28 +030072static u64 current_sessionid = 1;
NeilBrownfd39ca92005-06-23 22:04:03 -070073
74#define ZERO_STATEID(stateid) (!memcmp((stateid), &zerostateid, sizeof(stateid_t)))
75#define ONE_STATEID(stateid) (!memcmp((stateid), &onestateid, sizeof(stateid_t)))
Linus Torvalds1da177e2005-04-16 15:20:36 -070076
Linus Torvalds1da177e2005-04-16 15:20:36 -070077/* forward declarations */
NeilBrownfd39ca92005-06-23 22:04:03 -070078static struct nfs4_stateid * find_stateid(stateid_t *stid, int flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -070079static struct nfs4_delegation * find_delegation_stateid(struct inode *ino, stateid_t *stid);
NeilBrown0964a3d2005-06-23 22:04:32 -070080static char user_recovery_dirname[PATH_MAX] = "/var/lib/nfs/v4recovery";
81static void nfs4_set_recdir(char *recdir);
Linus Torvalds1da177e2005-04-16 15:20:36 -070082
J. Bruce Fields8b671b82009-02-22 14:51:34 -080083/* Locking: */
84
85/* Currently used for almost all code touching nfsv4 state: */
Ingo Molnar353ab6e2006-03-26 01:37:12 -080086static DEFINE_MUTEX(client_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070087
J. Bruce Fields8b671b82009-02-22 14:51:34 -080088/*
89 * Currently used for the del_recall_lru and file hash table. In an
90 * effort to decrease the scope of the client_mutex, this spinlock may
91 * eventually cover more:
92 */
93static DEFINE_SPINLOCK(recall_lock);
94
Christoph Lametere18b8902006-12-06 20:33:20 -080095static struct kmem_cache *stateowner_slab = NULL;
96static struct kmem_cache *file_slab = NULL;
97static struct kmem_cache *stateid_slab = NULL;
98static struct kmem_cache *deleg_slab = NULL;
NeilBrowne60d4392005-06-23 22:03:01 -070099
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100void
101nfs4_lock_state(void)
102{
Ingo Molnar353ab6e2006-03-26 01:37:12 -0800103 mutex_lock(&client_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104}
105
106void
107nfs4_unlock_state(void)
108{
Ingo Molnar353ab6e2006-03-26 01:37:12 -0800109 mutex_unlock(&client_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110}
111
112static inline u32
113opaque_hashval(const void *ptr, int nbytes)
114{
115 unsigned char *cptr = (unsigned char *) ptr;
116
117 u32 x = 0;
118 while (nbytes--) {
119 x *= 37;
120 x += *cptr++;
121 }
122 return x;
123}
124
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125static struct list_head del_recall_lru;
126
NeilBrown13cd2182005-06-23 22:03:10 -0700127static inline void
128put_nfs4_file(struct nfs4_file *fi)
129{
J. Bruce Fields8b671b82009-02-22 14:51:34 -0800130 if (atomic_dec_and_lock(&fi->fi_ref, &recall_lock)) {
131 list_del(&fi->fi_hash);
132 spin_unlock(&recall_lock);
133 iput(fi->fi_inode);
134 kmem_cache_free(file_slab, fi);
135 }
NeilBrown13cd2182005-06-23 22:03:10 -0700136}
137
138static inline void
139get_nfs4_file(struct nfs4_file *fi)
140{
J. Bruce Fields8b671b82009-02-22 14:51:34 -0800141 atomic_inc(&fi->fi_ref);
NeilBrown13cd2182005-06-23 22:03:10 -0700142}
143
NeilBrownef0f3392006-04-10 22:55:41 -0700144static int num_delegations;
Meelap Shahc2f1a552007-07-17 04:04:39 -0700145unsigned int max_delegations;
NeilBrownef0f3392006-04-10 22:55:41 -0700146
147/*
148 * Open owner state (share locks)
149 */
150
151/* hash tables for nfs4_stateowner */
152#define OWNER_HASH_BITS 8
153#define OWNER_HASH_SIZE (1 << OWNER_HASH_BITS)
154#define OWNER_HASH_MASK (OWNER_HASH_SIZE - 1)
155
156#define ownerid_hashval(id) \
157 ((id) & OWNER_HASH_MASK)
158#define ownerstr_hashval(clientid, ownername) \
159 (((clientid) + opaque_hashval((ownername.data), (ownername.len))) & OWNER_HASH_MASK)
160
161static struct list_head ownerid_hashtbl[OWNER_HASH_SIZE];
162static struct list_head ownerstr_hashtbl[OWNER_HASH_SIZE];
163
164/* hash table for nfs4_file */
165#define FILE_HASH_BITS 8
166#define FILE_HASH_SIZE (1 << FILE_HASH_BITS)
167#define FILE_HASH_MASK (FILE_HASH_SIZE - 1)
168/* hash table for (open)nfs4_stateid */
169#define STATEID_HASH_BITS 10
170#define STATEID_HASH_SIZE (1 << STATEID_HASH_BITS)
171#define STATEID_HASH_MASK (STATEID_HASH_SIZE - 1)
172
173#define file_hashval(x) \
174 hash_ptr(x, FILE_HASH_BITS)
175#define stateid_hashval(owner_id, file_id) \
176 (((owner_id) + (file_id)) & STATEID_HASH_MASK)
177
178static struct list_head file_hashtbl[FILE_HASH_SIZE];
179static struct list_head stateid_hashtbl[STATEID_HASH_SIZE];
180
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181static struct nfs4_delegation *
182alloc_init_deleg(struct nfs4_client *clp, struct nfs4_stateid *stp, struct svc_fh *current_fh, u32 type)
183{
184 struct nfs4_delegation *dp;
185 struct nfs4_file *fp = stp->st_file;
J. Bruce Fieldsc237dc02009-04-29 19:09:19 -0400186 struct nfs4_cb_conn *cb = &stp->st_stateowner->so_client->cl_cb_conn;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187
188 dprintk("NFSD alloc_init_deleg\n");
Meelap Shah47f99402007-07-17 04:04:40 -0700189 if (fp->fi_had_conflict)
190 return NULL;
Meelap Shahc2f1a552007-07-17 04:04:39 -0700191 if (num_delegations > max_delegations)
NeilBrownef0f3392006-04-10 22:55:41 -0700192 return NULL;
NeilBrown5b2d21c2005-06-23 22:03:04 -0700193 dp = kmem_cache_alloc(deleg_slab, GFP_KERNEL);
194 if (dp == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195 return dp;
NeilBrownef0f3392006-04-10 22:55:41 -0700196 num_delegations++;
NeilBrownea1da632005-06-23 22:04:17 -0700197 INIT_LIST_HEAD(&dp->dl_perfile);
198 INIT_LIST_HEAD(&dp->dl_perclnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199 INIT_LIST_HEAD(&dp->dl_recall_lru);
200 dp->dl_client = clp;
NeilBrown13cd2182005-06-23 22:03:10 -0700201 get_nfs4_file(fp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202 dp->dl_file = fp;
203 dp->dl_flock = NULL;
204 get_file(stp->st_vfs_file);
205 dp->dl_vfs_file = stp->st_vfs_file;
206 dp->dl_type = type;
J. Bruce Fieldsb53d40c2009-05-01 19:50:00 -0400207 dp->dl_ident = cb->cb_ident;
Bian Naimeng78155ed2009-04-22 18:25:37 +0800208 dp->dl_stateid.si_boot = get_seconds();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209 dp->dl_stateid.si_stateownerid = current_delegid++;
210 dp->dl_stateid.si_fileid = 0;
211 dp->dl_stateid.si_generation = 0;
J. Bruce Fields6c02eaa2009-02-02 17:30:51 -0500212 fh_copy_shallow(&dp->dl_fh, &current_fh->fh_handle);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213 dp->dl_time = 0;
214 atomic_set(&dp->dl_count, 1);
NeilBrownea1da632005-06-23 22:04:17 -0700215 list_add(&dp->dl_perfile, &fp->fi_delegations);
216 list_add(&dp->dl_perclnt, &clp->cl_delegations);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217 return dp;
218}
219
220void
221nfs4_put_delegation(struct nfs4_delegation *dp)
222{
223 if (atomic_dec_and_test(&dp->dl_count)) {
224 dprintk("NFSD: freeing dp %p\n",dp);
NeilBrown13cd2182005-06-23 22:03:10 -0700225 put_nfs4_file(dp->dl_file);
NeilBrown5b2d21c2005-06-23 22:03:04 -0700226 kmem_cache_free(deleg_slab, dp);
NeilBrownef0f3392006-04-10 22:55:41 -0700227 num_delegations--;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228 }
229}
230
231/* Remove the associated file_lock first, then remove the delegation.
232 * lease_modify() is called to remove the FS_LEASE file_lock from
233 * the i_flock list, eventually calling nfsd's lock_manager
234 * fl_release_callback.
235 */
236static void
237nfs4_close_delegation(struct nfs4_delegation *dp)
238{
239 struct file *filp = dp->dl_vfs_file;
240
241 dprintk("NFSD: close_delegation dp %p\n",dp);
242 dp->dl_vfs_file = NULL;
243 /* The following nfsd_close may not actually close the file,
244 * but we want to remove the lease in any case. */
NeilBrownc9071322005-04-16 15:26:38 -0700245 if (dp->dl_flock)
J. Bruce Fieldsa9933ce2007-06-07 17:09:49 -0400246 vfs_setlease(filp, F_UNLCK, &dp->dl_flock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247 nfsd_close(filp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248}
249
250/* Called under the state lock. */
251static void
252unhash_delegation(struct nfs4_delegation *dp)
253{
NeilBrownea1da632005-06-23 22:04:17 -0700254 list_del_init(&dp->dl_perfile);
255 list_del_init(&dp->dl_perclnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256 spin_lock(&recall_lock);
257 list_del_init(&dp->dl_recall_lru);
258 spin_unlock(&recall_lock);
259 nfs4_close_delegation(dp);
260 nfs4_put_delegation(dp);
261}
262
263/*
264 * SETCLIENTID state
265 */
266
267/* Hash tables for nfs4_clientid state */
268#define CLIENT_HASH_BITS 4
269#define CLIENT_HASH_SIZE (1 << CLIENT_HASH_BITS)
270#define CLIENT_HASH_MASK (CLIENT_HASH_SIZE - 1)
271
272#define clientid_hashval(id) \
273 ((id) & CLIENT_HASH_MASK)
NeilBrowna55370a2005-06-23 22:03:52 -0700274#define clientstr_hashval(name) \
275 (opaque_hashval((name), 8) & CLIENT_HASH_MASK)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276/*
277 * reclaim_str_hashtbl[] holds known client info from previous reset/reboot
278 * used in reboot/reset lease grace period processing
279 *
280 * conf_id_hashtbl[], and conf_str_hashtbl[] hold confirmed
281 * setclientid_confirmed info.
282 *
283 * unconf_str_hastbl[] and unconf_id_hashtbl[] hold unconfirmed
284 * setclientid info.
285 *
286 * client_lru holds client queue ordered by nfs4_client.cl_time
287 * for lease renewal.
288 *
289 * close_lru holds (open) stateowner queue ordered by nfs4_stateowner.so_time
290 * for last close replay.
291 */
292static struct list_head reclaim_str_hashtbl[CLIENT_HASH_SIZE];
293static int reclaim_str_hashtbl_size = 0;
294static struct list_head conf_id_hashtbl[CLIENT_HASH_SIZE];
295static struct list_head conf_str_hashtbl[CLIENT_HASH_SIZE];
296static struct list_head unconf_str_hashtbl[CLIENT_HASH_SIZE];
297static struct list_head unconf_id_hashtbl[CLIENT_HASH_SIZE];
298static struct list_head client_lru;
299static struct list_head close_lru;
300
J. Bruce Fields22839632009-01-11 14:27:17 -0500301static void unhash_generic_stateid(struct nfs4_stateid *stp)
302{
303 list_del(&stp->st_hash);
304 list_del(&stp->st_perfile);
305 list_del(&stp->st_perstateowner);
306}
307
308static void free_generic_stateid(struct nfs4_stateid *stp)
309{
310 put_nfs4_file(stp->st_file);
311 kmem_cache_free(stateid_slab, stp);
312}
313
314static void release_lock_stateid(struct nfs4_stateid *stp)
315{
316 unhash_generic_stateid(stp);
317 locks_remove_posix(stp->st_vfs_file, (fl_owner_t)stp->st_stateowner);
318 free_generic_stateid(stp);
319}
320
J. Bruce Fieldsf044ff82009-01-11 15:24:04 -0500321static void unhash_lockowner(struct nfs4_stateowner *sop)
322{
323 struct nfs4_stateid *stp;
324
325 list_del(&sop->so_idhash);
326 list_del(&sop->so_strhash);
327 list_del(&sop->so_perstateid);
328 while (!list_empty(&sop->so_stateids)) {
329 stp = list_first_entry(&sop->so_stateids,
330 struct nfs4_stateid, st_perstateowner);
331 release_lock_stateid(stp);
332 }
333}
334
335static void release_lockowner(struct nfs4_stateowner *sop)
336{
337 unhash_lockowner(sop);
338 nfs4_put_stateowner(sop);
339}
340
J. Bruce Fieldsf1d110c2009-01-11 14:37:31 -0500341static void
342release_stateid_lockowners(struct nfs4_stateid *open_stp)
343{
344 struct nfs4_stateowner *lock_sop;
345
346 while (!list_empty(&open_stp->st_lockowners)) {
347 lock_sop = list_entry(open_stp->st_lockowners.next,
348 struct nfs4_stateowner, so_perstateid);
349 /* list_del(&open_stp->st_lockowners); */
350 BUG_ON(lock_sop->so_is_open_owner);
J. Bruce Fieldsf044ff82009-01-11 15:24:04 -0500351 release_lockowner(lock_sop);
J. Bruce Fieldsf1d110c2009-01-11 14:37:31 -0500352 }
353}
354
J. Bruce Fields22839632009-01-11 14:27:17 -0500355static void release_open_stateid(struct nfs4_stateid *stp)
356{
357 unhash_generic_stateid(stp);
358 release_stateid_lockowners(stp);
359 nfsd_close(stp->st_vfs_file);
360 free_generic_stateid(stp);
361}
362
J. Bruce Fieldsf044ff82009-01-11 15:24:04 -0500363static void unhash_openowner(struct nfs4_stateowner *sop)
J. Bruce Fieldsf1d110c2009-01-11 14:37:31 -0500364{
365 struct nfs4_stateid *stp;
366
367 list_del(&sop->so_idhash);
368 list_del(&sop->so_strhash);
J. Bruce Fieldsf044ff82009-01-11 15:24:04 -0500369 list_del(&sop->so_perclient);
370 list_del(&sop->so_perstateid); /* XXX: necessary? */
J. Bruce Fieldsf1d110c2009-01-11 14:37:31 -0500371 while (!list_empty(&sop->so_stateids)) {
J. Bruce Fieldsf044ff82009-01-11 15:24:04 -0500372 stp = list_first_entry(&sop->so_stateids,
373 struct nfs4_stateid, st_perstateowner);
374 release_open_stateid(stp);
J. Bruce Fieldsf1d110c2009-01-11 14:37:31 -0500375 }
376}
377
J. Bruce Fieldsf044ff82009-01-11 15:24:04 -0500378static void release_openowner(struct nfs4_stateowner *sop)
J. Bruce Fieldsf1d110c2009-01-11 14:37:31 -0500379{
J. Bruce Fieldsf044ff82009-01-11 15:24:04 -0500380 unhash_openowner(sop);
J. Bruce Fieldsf1d110c2009-01-11 14:37:31 -0500381 list_del(&sop->so_close_lru);
382 nfs4_put_stateowner(sop);
383}
384
Marc Eshel5282fd72009-04-03 08:27:52 +0300385static DEFINE_SPINLOCK(sessionid_lock);
386#define SESSION_HASH_SIZE 512
387static struct list_head sessionid_hashtbl[SESSION_HASH_SIZE];
388
389static inline int
390hash_sessionid(struct nfs4_sessionid *sessionid)
391{
392 struct nfsd4_sessionid *sid = (struct nfsd4_sessionid *)sessionid;
393
394 return sid->sequence % SESSION_HASH_SIZE;
395}
396
397static inline void
398dump_sessionid(const char *fn, struct nfs4_sessionid *sessionid)
399{
400 u32 *ptr = (u32 *)(&sessionid->data[0]);
401 dprintk("%s: %u:%u:%u:%u\n", fn, ptr[0], ptr[1], ptr[2], ptr[3]);
402}
403
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300404static void
405gen_sessionid(struct nfsd4_session *ses)
406{
407 struct nfs4_client *clp = ses->se_client;
408 struct nfsd4_sessionid *sid;
409
410 sid = (struct nfsd4_sessionid *)ses->se_sessionid.data;
411 sid->clientid = clp->cl_clientid;
412 sid->sequence = current_sessionid++;
413 sid->reserved = 0;
414}
415
416/*
Andy Adamsona6496372009-08-28 08:45:01 -0400417 * The protocol defines ca_maxresponssize_cached to include the size of
418 * the rpc header, but all we need to cache is the data starting after
419 * the end of the initial SEQUENCE operation--the rest we regenerate
420 * each time. Therefore we can advertise a ca_maxresponssize_cached
421 * value that is the number of bytes in our cache plus a few additional
422 * bytes. In order to stay on the safe side, and not promise more than
423 * we can cache, those additional bytes must be the minimum possible: 24
424 * bytes of rpc header (xid through accept state, with AUTH_NULL
425 * verifier), 12 for the compound header (with zero-length tag), and 44
426 * for the SEQUENCE op response:
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300427 */
Andy Adamsona6496372009-08-28 08:45:01 -0400428#define NFSD_MIN_HDR_SEQ_SZ (24 + 12 + 44)
429
430/*
431 * Give the client the number of ca_maxresponsesize_cached slots it
432 * requests, of size bounded by NFSD_SLOT_CACHE_SIZE,
433 * NFSD_MAX_MEM_PER_SESSION, and nfsd_drc_max_mem. Do not allow more
434 * than NFSD_MAX_SLOTS_PER_SESSION.
435 *
436 * If we run out of reserved DRC memory we should (up to a point)
437 * re-negotiate active sessions and reduce their slot usage to make
438 * rooom for new connections. For now we just fail the create session.
439 */
440static int set_forechannel_drc_size(struct nfsd4_channel_attrs *fchan)
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300441{
Andy Adamsona6496372009-08-28 08:45:01 -0400442 int mem, size = fchan->maxresp_cached;
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300443
Andy Adamson5d77ddf2009-06-16 04:19:38 +0300444 if (fchan->maxreqs < 1)
445 return nfserr_inval;
Andy Adamson5d77ddf2009-06-16 04:19:38 +0300446
Andy Adamsona6496372009-08-28 08:45:01 -0400447 if (size < NFSD_MIN_HDR_SEQ_SZ)
448 size = NFSD_MIN_HDR_SEQ_SZ;
449 size -= NFSD_MIN_HDR_SEQ_SZ;
450 if (size > NFSD_SLOT_CACHE_SIZE)
451 size = NFSD_SLOT_CACHE_SIZE;
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300452
Andy Adamsona6496372009-08-28 08:45:01 -0400453 /* bound the maxreqs by NFSD_MAX_MEM_PER_SESSION */
454 mem = fchan->maxreqs * size;
455 if (mem > NFSD_MAX_MEM_PER_SESSION) {
456 fchan->maxreqs = NFSD_MAX_MEM_PER_SESSION / size;
457 if (fchan->maxreqs > NFSD_MAX_SLOTS_PER_SESSION)
458 fchan->maxreqs = NFSD_MAX_SLOTS_PER_SESSION;
459 mem = fchan->maxreqs * size;
460 }
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300461
Andy Adamson4bd9b0f2009-06-24 15:37:45 -0400462 spin_lock(&nfsd_drc_lock);
Andy Adamsona6496372009-08-28 08:45:01 -0400463 /* bound the total session drc memory ussage */
464 if (mem + nfsd_drc_mem_used > nfsd_drc_max_mem) {
465 fchan->maxreqs = (nfsd_drc_max_mem - nfsd_drc_mem_used) / size;
466 mem = fchan->maxreqs * size;
467 }
Andy Adamson0c193052009-07-27 19:09:19 -0400468 nfsd_drc_mem_used += mem;
Andy Adamson4bd9b0f2009-06-24 15:37:45 -0400469 spin_unlock(&nfsd_drc_lock);
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300470
Andy Adamsonb101ebb2009-07-27 18:40:09 -0400471 if (fchan->maxreqs == 0)
Andy Adamsonbdac86e2009-08-28 08:45:03 -0400472 return nfserr_serverfault;
Andy Adamsona6496372009-08-28 08:45:01 -0400473
474 fchan->maxresp_cached = size + NFSD_MIN_HDR_SEQ_SZ;
Andy Adamsonb101ebb2009-07-27 18:40:09 -0400475 return 0;
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300476}
477
478/*
479 * fchan holds the client values on input, and the server values on output
480 */
481static int init_forechannel_attrs(struct svc_rqst *rqstp,
Alexandros Batsakis6c18ba92009-06-16 04:19:13 +0300482 struct nfsd4_channel_attrs *session_fchan,
483 struct nfsd4_channel_attrs *fchan)
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300484{
485 int status = 0;
486 __u32 maxcount = svc_max_payload(rqstp);
487
488 /* headerpadsz set to zero in encode routine */
489
490 /* Use the client's max request and max response size if possible */
491 if (fchan->maxreq_sz > maxcount)
492 fchan->maxreq_sz = maxcount;
Alexandros Batsakis6c18ba92009-06-16 04:19:13 +0300493 session_fchan->maxreq_sz = fchan->maxreq_sz;
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300494
495 if (fchan->maxresp_sz > maxcount)
496 fchan->maxresp_sz = maxcount;
Alexandros Batsakis6c18ba92009-06-16 04:19:13 +0300497 session_fchan->maxresp_sz = fchan->maxresp_sz;
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300498
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300499 /* Use the client's maxops if possible */
500 if (fchan->maxops > NFSD_MAX_OPS_PER_COMPOUND)
501 fchan->maxops = NFSD_MAX_OPS_PER_COMPOUND;
Alexandros Batsakis6c18ba92009-06-16 04:19:13 +0300502 session_fchan->maxops = fchan->maxops;
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300503
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300504 /* FIXME: Error means no more DRC pages so the server should
505 * recover pages from existing sessions. For now fail session
506 * creation.
507 */
Andy Adamsona6496372009-08-28 08:45:01 -0400508 status = set_forechannel_drc_size(fchan);
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300509
Andy Adamsona6496372009-08-28 08:45:01 -0400510 session_fchan->maxresp_cached = fchan->maxresp_cached;
Alexandros Batsakis6c18ba92009-06-16 04:19:13 +0300511 session_fchan->maxreqs = fchan->maxreqs;
Andy Adamsona6496372009-08-28 08:45:01 -0400512
513 dprintk("%s status %d\n", __func__, status);
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300514 return status;
515}
516
Andy Adamson557ce262009-08-28 08:45:04 -0400517static void
518free_session_slots(struct nfsd4_session *ses)
519{
520 int i;
521
522 for (i = 0; i < ses->se_fchannel.maxreqs; i++)
523 kfree(ses->se_slots[i]);
524}
525
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300526static int
527alloc_init_session(struct svc_rqst *rqstp, struct nfs4_client *clp,
528 struct nfsd4_create_session *cses)
529{
530 struct nfsd4_session *new, tmp;
Andy Adamson557ce262009-08-28 08:45:04 -0400531 struct nfsd4_slot *sp;
532 int idx, slotsize, cachesize, i;
533 int status;
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300534
535 memset(&tmp, 0, sizeof(tmp));
536
537 /* FIXME: For now, we just accept the client back channel attributes. */
Alexandros Batsakis6c18ba92009-06-16 04:19:13 +0300538 tmp.se_bchannel = cses->back_channel;
539 status = init_forechannel_attrs(rqstp, &tmp.se_fchannel,
540 &cses->fore_channel);
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300541 if (status)
542 goto out;
543
Andy Adamson557ce262009-08-28 08:45:04 -0400544 BUILD_BUG_ON(NFSD_MAX_SLOTS_PER_SESSION * sizeof(struct nfsd4_slot)
545 + sizeof(struct nfsd4_session) > PAGE_SIZE);
546
547 status = nfserr_serverfault;
548 /* allocate struct nfsd4_session and slot table pointers in one piece */
549 slotsize = tmp.se_fchannel.maxreqs * sizeof(struct nfsd4_slot *);
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300550 new = kzalloc(sizeof(*new) + slotsize, GFP_KERNEL);
551 if (!new)
552 goto out;
553
554 memcpy(new, &tmp, sizeof(*new));
555
Andy Adamson557ce262009-08-28 08:45:04 -0400556 /* allocate each struct nfsd4_slot and data cache in one piece */
557 cachesize = new->se_fchannel.maxresp_cached - NFSD_MIN_HDR_SEQ_SZ;
558 for (i = 0; i < new->se_fchannel.maxreqs; i++) {
559 sp = kzalloc(sizeof(*sp) + cachesize, GFP_KERNEL);
560 if (!sp)
561 goto out_free;
562 new->se_slots[i] = sp;
563 }
564
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300565 new->se_client = clp;
566 gen_sessionid(new);
567 idx = hash_sessionid(&new->se_sessionid);
568 memcpy(clp->cl_sessionid.data, new->se_sessionid.data,
569 NFS4_MAX_SESSIONID_LEN);
570
571 new->se_flags = cses->flags;
572 kref_init(&new->se_ref);
573 spin_lock(&sessionid_lock);
574 list_add(&new->se_hash, &sessionid_hashtbl[idx]);
575 list_add(&new->se_perclnt, &clp->cl_sessions);
576 spin_unlock(&sessionid_lock);
577
578 status = nfs_ok;
579out:
580 return status;
Andy Adamson557ce262009-08-28 08:45:04 -0400581out_free:
582 free_session_slots(new);
583 kfree(new);
584 goto out;
Andy Adamsonec6b5d72009-04-03 08:28:28 +0300585}
586
Marc Eshel5282fd72009-04-03 08:27:52 +0300587/* caller must hold sessionid_lock */
588static struct nfsd4_session *
589find_in_sessionid_hashtbl(struct nfs4_sessionid *sessionid)
590{
591 struct nfsd4_session *elem;
592 int idx;
593
594 dump_sessionid(__func__, sessionid);
595 idx = hash_sessionid(sessionid);
596 dprintk("%s: idx is %d\n", __func__, idx);
597 /* Search in the appropriate list */
598 list_for_each_entry(elem, &sessionid_hashtbl[idx], se_hash) {
599 dump_sessionid("list traversal", &elem->se_sessionid);
600 if (!memcmp(elem->se_sessionid.data, sessionid->data,
601 NFS4_MAX_SESSIONID_LEN)) {
602 return elem;
603 }
604 }
605
606 dprintk("%s: session not found\n", __func__);
607 return NULL;
608}
609
610/* caller must hold sessionid_lock */
Andy Adamson7116ed62009-04-03 08:27:43 +0300611static void
Marc Eshel5282fd72009-04-03 08:27:52 +0300612unhash_session(struct nfsd4_session *ses)
Andy Adamson7116ed62009-04-03 08:27:43 +0300613{
614 list_del(&ses->se_hash);
615 list_del(&ses->se_perclnt);
Marc Eshel5282fd72009-04-03 08:27:52 +0300616}
617
618static void
619release_session(struct nfsd4_session *ses)
620{
621 spin_lock(&sessionid_lock);
622 unhash_session(ses);
623 spin_unlock(&sessionid_lock);
Andy Adamson7116ed62009-04-03 08:27:43 +0300624 nfsd4_put_session(ses);
625}
626
627void
628free_session(struct kref *kref)
629{
630 struct nfsd4_session *ses;
631
632 ses = container_of(kref, struct nfsd4_session, se_ref);
Andy Adamsonbe98d1b2009-07-27 18:49:05 -0400633 spin_lock(&nfsd_drc_lock);
Andy Adamson0c193052009-07-27 19:09:19 -0400634 nfsd_drc_mem_used -= ses->se_fchannel.maxreqs * NFSD_SLOT_CACHE_SIZE;
Andy Adamsonbe98d1b2009-07-27 18:49:05 -0400635 spin_unlock(&nfsd_drc_lock);
Andy Adamson557ce262009-08-28 08:45:04 -0400636 free_session_slots(ses);
Andy Adamson7116ed62009-04-03 08:27:43 +0300637 kfree(ses);
638}
639
Linus Torvalds1da177e2005-04-16 15:20:36 -0700640static inline void
641renew_client(struct nfs4_client *clp)
642{
643 /*
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
653/* SETCLIENTID and SETCLIENTID_CONFIRM Helper functions */
654static int
655STALE_CLIENTID(clientid_t *clid)
656{
657 if (clid->cl_boot == boot_time)
658 return 0;
Andy Adamson60adfc52009-04-03 08:28:50 +0300659 dprintk("NFSD stale clientid (%08x/%08x) boot_time %08lx\n",
660 clid->cl_boot, clid->cl_id, boot_time);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661 return 1;
662}
663
664/*
665 * XXX Should we use a slab cache ?
666 * This type of memory management is somewhat inefficient, but we use it
667 * anyway since SETCLIENTID is not a common operation.
668 */
J. Bruce Fields35bba9a2007-11-21 22:07:08 -0500669static struct nfs4_client *alloc_client(struct xdr_netobj name)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700670{
671 struct nfs4_client *clp;
672
J. Bruce Fields35bba9a2007-11-21 22:07:08 -0500673 clp = kzalloc(sizeof(struct nfs4_client), GFP_KERNEL);
674 if (clp == NULL)
675 return NULL;
676 clp->cl_name.data = kmalloc(name.len, GFP_KERNEL);
677 if (clp->cl_name.data == NULL) {
678 kfree(clp);
679 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680 }
J. Bruce Fields35bba9a2007-11-21 22:07:08 -0500681 memcpy(clp->cl_name.data, name.data, name.len);
682 clp->cl_name.len = name.len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700683 return clp;
684}
685
J. Bruce Fields1b1a9b32007-09-12 08:43:59 -0400686static void
687shutdown_callback_client(struct nfs4_client *clp)
688{
J. Bruce Fieldsc237dc02009-04-29 19:09:19 -0400689 struct rpc_clnt *clnt = clp->cl_cb_conn.cb_client;
J. Bruce Fields1b1a9b32007-09-12 08:43:59 -0400690
J. Bruce Fields1b1a9b32007-09-12 08:43:59 -0400691 if (clnt) {
J. Bruce Fields404ec112007-11-23 22:26:18 -0500692 /*
693 * Callback threads take a reference on the client, so there
694 * should be no outstanding callbacks at this point.
695 */
J. Bruce Fieldsc237dc02009-04-29 19:09:19 -0400696 clp->cl_cb_conn.cb_client = NULL;
J. Bruce Fields1b1a9b32007-09-12 08:43:59 -0400697 rpc_shutdown_client(clnt);
698 }
699}
700
Linus Torvalds1da177e2005-04-16 15:20:36 -0700701static inline void
702free_client(struct nfs4_client *clp)
703{
J. Bruce Fields1b1a9b32007-09-12 08:43:59 -0400704 shutdown_callback_client(clp);
Andy Adamson38524ab2009-09-10 12:25:59 +0300705 if (clp->cl_cb_xprt)
706 svc_xprt_put(clp->cl_cb_xprt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707 if (clp->cl_cred.cr_group_info)
708 put_group_info(clp->cl_cred.cr_group_info);
Olga Kornievskaia68e76ad2008-12-23 16:17:15 -0500709 kfree(clp->cl_principal);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700710 kfree(clp->cl_name.data);
711 kfree(clp);
712}
713
714void
715put_nfs4_client(struct nfs4_client *clp)
716{
717 if (atomic_dec_and_test(&clp->cl_count))
718 free_client(clp);
719}
720
721static void
722expire_client(struct nfs4_client *clp)
723{
724 struct nfs4_stateowner *sop;
725 struct nfs4_delegation *dp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700726 struct list_head reaplist;
727
728 dprintk("NFSD: expire_client cl_count %d\n",
729 atomic_read(&clp->cl_count));
730
Linus Torvalds1da177e2005-04-16 15:20:36 -0700731 INIT_LIST_HEAD(&reaplist);
732 spin_lock(&recall_lock);
NeilBrownea1da632005-06-23 22:04:17 -0700733 while (!list_empty(&clp->cl_delegations)) {
734 dp = list_entry(clp->cl_delegations.next, struct nfs4_delegation, dl_perclnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700735 dprintk("NFSD: expire client. dp %p, fp %p\n", dp,
736 dp->dl_flock);
NeilBrownea1da632005-06-23 22:04:17 -0700737 list_del_init(&dp->dl_perclnt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700738 list_move(&dp->dl_recall_lru, &reaplist);
739 }
740 spin_unlock(&recall_lock);
741 while (!list_empty(&reaplist)) {
742 dp = list_entry(reaplist.next, struct nfs4_delegation, dl_recall_lru);
743 list_del_init(&dp->dl_recall_lru);
744 unhash_delegation(dp);
745 }
746 list_del(&clp->cl_idhash);
747 list_del(&clp->cl_strhash);
748 list_del(&clp->cl_lru);
NeilBrownea1da632005-06-23 22:04:17 -0700749 while (!list_empty(&clp->cl_openowners)) {
750 sop = list_entry(clp->cl_openowners.next, struct nfs4_stateowner, so_perclient);
J. Bruce Fieldsf044ff82009-01-11 15:24:04 -0500751 release_openowner(sop);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700752 }
Marc Eshelc4bf7862009-04-03 08:27:49 +0300753 while (!list_empty(&clp->cl_sessions)) {
754 struct nfsd4_session *ses;
755 ses = list_entry(clp->cl_sessions.next, struct nfsd4_session,
756 se_perclnt);
757 release_session(ses);
758 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700759 put_nfs4_client(clp);
760}
761
J. Bruce Fields35bba9a2007-11-21 22:07:08 -0500762static void copy_verf(struct nfs4_client *target, nfs4_verifier *source)
763{
764 memcpy(target->cl_verifier.data, source->data,
765 sizeof(target->cl_verifier.data));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700766}
767
J. Bruce Fields35bba9a2007-11-21 22:07:08 -0500768static void copy_clid(struct nfs4_client *target, struct nfs4_client *source)
769{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770 target->cl_clientid.cl_boot = source->cl_clientid.cl_boot;
771 target->cl_clientid.cl_id = source->cl_clientid.cl_id;
772}
773
J. Bruce Fields35bba9a2007-11-21 22:07:08 -0500774static void copy_cred(struct svc_cred *target, struct svc_cred *source)
775{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700776 target->cr_uid = source->cr_uid;
777 target->cr_gid = source->cr_gid;
778 target->cr_group_info = source->cr_group_info;
779 get_group_info(target->cr_group_info);
780}
781
J. Bruce Fields35bba9a2007-11-21 22:07:08 -0500782static int same_name(const char *n1, const char *n2)
J. Bruce Fields599e0a22007-07-26 17:04:54 -0400783{
NeilBrowna55370a2005-06-23 22:03:52 -0700784 return 0 == memcmp(n1, n2, HEXDIR_LEN);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700785}
786
787static int
J. Bruce Fields599e0a22007-07-26 17:04:54 -0400788same_verf(nfs4_verifier *v1, nfs4_verifier *v2)
789{
790 return 0 == memcmp(v1->data, v2->data, sizeof(v1->data));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700791}
792
793static int
J. Bruce Fields599e0a22007-07-26 17:04:54 -0400794same_clid(clientid_t *cl1, clientid_t *cl2)
795{
796 return (cl1->cl_boot == cl2->cl_boot) && (cl1->cl_id == cl2->cl_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700797}
798
799/* XXX what about NGROUP */
800static int
J. Bruce Fields599e0a22007-07-26 17:04:54 -0400801same_creds(struct svc_cred *cr1, struct svc_cred *cr2)
802{
803 return cr1->cr_uid == cr2->cr_uid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804}
805
J. Bruce Fields5ec7b462007-11-21 21:58:56 -0500806static void gen_clid(struct nfs4_client *clp)
807{
808 static u32 current_clientid = 1;
809
Linus Torvalds1da177e2005-04-16 15:20:36 -0700810 clp->cl_clientid.cl_boot = boot_time;
811 clp->cl_clientid.cl_id = current_clientid++;
812}
813
J. Bruce Fieldsdeda2fa2007-11-19 20:31:04 -0500814static void gen_confirm(struct nfs4_client *clp)
815{
816 static u32 i;
817 u32 *p;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700818
Linus Torvalds1da177e2005-04-16 15:20:36 -0700819 p = (u32 *)clp->cl_confirm.data;
J. Bruce Fieldsdeda2fa2007-11-19 20:31:04 -0500820 *p++ = get_seconds();
821 *p++ = i++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700822}
823
Ricardo Labiagab09333c2009-09-10 12:27:34 +0300824static struct nfs4_client *create_client(struct xdr_netobj name, char *recdir,
825 struct svc_rqst *rqstp, nfs4_verifier *verf)
826{
827 struct nfs4_client *clp;
828 struct sockaddr *sa = svc_addr(rqstp);
829 char *princ;
830
831 clp = alloc_client(name);
832 if (clp == NULL)
833 return NULL;
834
835 princ = svc_gss_principal(rqstp);
836 if (princ) {
837 clp->cl_principal = kstrdup(princ, GFP_KERNEL);
838 if (clp->cl_principal == NULL) {
839 free_client(clp);
840 return NULL;
841 }
842 }
843
844 memcpy(clp->cl_recdir, recdir, HEXDIR_LEN);
845 atomic_set(&clp->cl_count, 1);
846 atomic_set(&clp->cl_cb_conn.cb_set, 0);
847 INIT_LIST_HEAD(&clp->cl_idhash);
848 INIT_LIST_HEAD(&clp->cl_strhash);
849 INIT_LIST_HEAD(&clp->cl_openowners);
850 INIT_LIST_HEAD(&clp->cl_delegations);
851 INIT_LIST_HEAD(&clp->cl_sessions);
852 INIT_LIST_HEAD(&clp->cl_lru);
853 clear_bit(0, &clp->cl_cb_slot_busy);
854 rpc_init_wait_queue(&clp->cl_cb_waitq, "Backchannel slot table");
855 copy_verf(clp, verf);
856 rpc_copy_addr((struct sockaddr *) &clp->cl_addr, sa);
857 clp->cl_flavor = rqstp->rq_flavor;
858 copy_cred(&clp->cl_cred, &rqstp->rq_cred);
859 gen_confirm(clp);
860
861 return clp;
862}
863
J. Bruce Fields35bba9a2007-11-21 22:07:08 -0500864static int check_name(struct xdr_netobj name)
865{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700866 if (name.len == 0)
867 return 0;
868 if (name.len > NFS4_OPAQUE_LIMIT) {
J. Bruce Fields2fdada02007-07-27 16:10:37 -0400869 dprintk("NFSD: check_name: name too long(%d)!\n", name.len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700870 return 0;
871 }
872 return 1;
873}
874
NeilBrownfd39ca92005-06-23 22:04:03 -0700875static void
Linus Torvalds1da177e2005-04-16 15:20:36 -0700876add_to_unconfirmed(struct nfs4_client *clp, unsigned int strhashval)
877{
878 unsigned int idhashval;
879
880 list_add(&clp->cl_strhash, &unconf_str_hashtbl[strhashval]);
881 idhashval = clientid_hashval(clp->cl_clientid.cl_id);
882 list_add(&clp->cl_idhash, &unconf_id_hashtbl[idhashval]);
883 list_add_tail(&clp->cl_lru, &client_lru);
884 clp->cl_time = get_seconds();
885}
886
NeilBrownfd39ca92005-06-23 22:04:03 -0700887static void
Linus Torvalds1da177e2005-04-16 15:20:36 -0700888move_to_confirmed(struct nfs4_client *clp)
889{
890 unsigned int idhashval = clientid_hashval(clp->cl_clientid.cl_id);
891 unsigned int strhashval;
892
893 dprintk("NFSD: move_to_confirm nfs4_client %p\n", clp);
894 list_del_init(&clp->cl_strhash);
Akinobu Mitaf1166292006-06-26 00:24:46 -0700895 list_move(&clp->cl_idhash, &conf_id_hashtbl[idhashval]);
NeilBrowna55370a2005-06-23 22:03:52 -0700896 strhashval = clientstr_hashval(clp->cl_recdir);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700897 list_add(&clp->cl_strhash, &conf_str_hashtbl[strhashval]);
898 renew_client(clp);
899}
900
901static struct nfs4_client *
902find_confirmed_client(clientid_t *clid)
903{
904 struct nfs4_client *clp;
905 unsigned int idhashval = clientid_hashval(clid->cl_id);
906
907 list_for_each_entry(clp, &conf_id_hashtbl[idhashval], cl_idhash) {
J. Bruce Fields599e0a22007-07-26 17:04:54 -0400908 if (same_clid(&clp->cl_clientid, clid))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700909 return clp;
910 }
911 return NULL;
912}
913
914static struct nfs4_client *
915find_unconfirmed_client(clientid_t *clid)
916{
917 struct nfs4_client *clp;
918 unsigned int idhashval = clientid_hashval(clid->cl_id);
919
920 list_for_each_entry(clp, &unconf_id_hashtbl[idhashval], cl_idhash) {
J. Bruce Fields599e0a22007-07-26 17:04:54 -0400921 if (same_clid(&clp->cl_clientid, clid))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700922 return clp;
923 }
924 return NULL;
925}
926
Andy Adamsona1bcecd2009-04-03 08:28:05 +0300927/*
928 * Return 1 iff clp's clientid establishment method matches the use_exchange_id
929 * parameter. Matching is based on the fact the at least one of the
930 * EXCHGID4_FLAG_USE_{NON_PNFS,PNFS_MDS,PNFS_DS} flags must be set for v4.1
931 *
932 * FIXME: we need to unify the clientid namespaces for nfsv4.x
933 * and correctly deal with client upgrade/downgrade in EXCHANGE_ID
934 * and SET_CLIENTID{,_CONFIRM}
935 */
936static inline int
937match_clientid_establishment(struct nfs4_client *clp, bool use_exchange_id)
938{
939 bool has_exchange_flags = (clp->cl_exchange_flags != 0);
940 return use_exchange_id == has_exchange_flags;
941}
942
NeilBrown28ce6052005-06-23 22:03:56 -0700943static struct nfs4_client *
Andy Adamsona1bcecd2009-04-03 08:28:05 +0300944find_confirmed_client_by_str(const char *dname, unsigned int hashval,
945 bool use_exchange_id)
NeilBrown28ce6052005-06-23 22:03:56 -0700946{
947 struct nfs4_client *clp;
948
949 list_for_each_entry(clp, &conf_str_hashtbl[hashval], cl_strhash) {
Andy Adamsona1bcecd2009-04-03 08:28:05 +0300950 if (same_name(clp->cl_recdir, dname) &&
951 match_clientid_establishment(clp, use_exchange_id))
NeilBrown28ce6052005-06-23 22:03:56 -0700952 return clp;
953 }
954 return NULL;
955}
956
957static struct nfs4_client *
Andy Adamsona1bcecd2009-04-03 08:28:05 +0300958find_unconfirmed_client_by_str(const char *dname, unsigned int hashval,
959 bool use_exchange_id)
NeilBrown28ce6052005-06-23 22:03:56 -0700960{
961 struct nfs4_client *clp;
962
963 list_for_each_entry(clp, &unconf_str_hashtbl[hashval], cl_strhash) {
Andy Adamsona1bcecd2009-04-03 08:28:05 +0300964 if (same_name(clp->cl_recdir, dname) &&
965 match_clientid_establishment(clp, use_exchange_id))
NeilBrown28ce6052005-06-23 22:03:56 -0700966 return clp;
967 }
968 return NULL;
969}
970
NeilBrownfd39ca92005-06-23 22:04:03 -0700971static void
Jeff Laytonfbf46652009-08-14 12:57:59 -0400972gen_callback(struct nfs4_client *clp, struct nfsd4_setclientid *se, u32 scopeid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700973{
J. Bruce Fieldsc237dc02009-04-29 19:09:19 -0400974 struct nfs4_cb_conn *cb = &clp->cl_cb_conn;
Jeff Layton7077ecb2009-08-14 12:57:58 -0400975 unsigned short expected_family;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700976
Jeff Layton7077ecb2009-08-14 12:57:58 -0400977 /* Currently, we only support tcp and tcp6 for the callback channel */
978 if (se->se_callback_netid_len == 3 &&
979 !memcmp(se->se_callback_netid_val, "tcp", 3))
980 expected_family = AF_INET;
981 else if (se->se_callback_netid_len == 4 &&
982 !memcmp(se->se_callback_netid_val, "tcp6", 4))
983 expected_family = AF_INET6;
984 else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700985 goto out_err;
986
Jeff Laytonaa9a4ec2009-08-14 12:57:57 -0400987 cb->cb_addrlen = rpc_uaddr2sockaddr(se->se_callback_addr_val,
988 se->se_callback_addr_len,
989 (struct sockaddr *) &cb->cb_addr,
990 sizeof(cb->cb_addr));
991
Jeff Layton7077ecb2009-08-14 12:57:58 -0400992 if (!cb->cb_addrlen || cb->cb_addr.ss_family != expected_family)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700993 goto out_err;
Jeff Laytonaa9a4ec2009-08-14 12:57:57 -0400994
Jeff Laytonfbf46652009-08-14 12:57:59 -0400995 if (cb->cb_addr.ss_family == AF_INET6)
996 ((struct sockaddr_in6 *) &cb->cb_addr)->sin6_scope_id = scopeid;
997
Andy Adamsonab52ae62009-06-16 04:20:53 +0300998 cb->cb_minorversion = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700999 cb->cb_prog = se->se_callback_prog;
1000 cb->cb_ident = se->se_callback_ident;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001001 return;
1002out_err:
Jeff Laytonaa9a4ec2009-08-14 12:57:57 -04001003 cb->cb_addr.ss_family = AF_UNSPEC;
1004 cb->cb_addrlen = 0;
Neil Brown849823c2005-09-13 01:25:36 -07001005 dprintk(KERN_INFO "NFSD: this client (clientid %08x/%08x) "
Linus Torvalds1da177e2005-04-16 15:20:36 -07001006 "will not receive delegations\n",
1007 clp->cl_clientid.cl_boot, clp->cl_clientid.cl_id);
1008
Linus Torvalds1da177e2005-04-16 15:20:36 -07001009 return;
1010}
1011
Andy Adamson074fe892009-04-03 08:28:15 +03001012/*
Andy Adamson557ce262009-08-28 08:45:04 -04001013 * Cache a reply. nfsd4_check_drc_limit() has bounded the cache size.
Andy Adamson074fe892009-04-03 08:28:15 +03001014 */
1015void
1016nfsd4_store_cache_entry(struct nfsd4_compoundres *resp)
1017{
Andy Adamson557ce262009-08-28 08:45:04 -04001018 struct nfsd4_slot *slot = resp->cstate.slot;
1019 unsigned int base;
Andy Adamson074fe892009-04-03 08:28:15 +03001020
Andy Adamson557ce262009-08-28 08:45:04 -04001021 dprintk("--> %s slot %p\n", __func__, slot);
Andy Adamson074fe892009-04-03 08:28:15 +03001022
Andy Adamson557ce262009-08-28 08:45:04 -04001023 slot->sl_opcnt = resp->opcnt;
1024 slot->sl_status = resp->cstate.status;
Andy Adamsonbf864a32009-04-03 08:28:35 +03001025
1026 if (nfsd4_not_cached(resp)) {
Andy Adamson557ce262009-08-28 08:45:04 -04001027 slot->sl_datalen = 0;
Andy Adamsonbf864a32009-04-03 08:28:35 +03001028 return;
1029 }
Andy Adamson557ce262009-08-28 08:45:04 -04001030 slot->sl_datalen = (char *)resp->p - (char *)resp->cstate.datap;
1031 base = (char *)resp->cstate.datap -
1032 (char *)resp->xbuf->head[0].iov_base;
1033 if (read_bytes_from_xdr_buf(resp->xbuf, base, slot->sl_data,
1034 slot->sl_datalen))
1035 WARN("%s: sessions DRC could not cache compound\n", __func__);
1036 return;
Andy Adamson074fe892009-04-03 08:28:15 +03001037}
1038
1039/*
Andy Adamsonabfabf82009-07-23 19:02:18 -04001040 * Encode the replay sequence operation from the slot values.
1041 * If cachethis is FALSE encode the uncached rep error on the next
1042 * operation which sets resp->p and increments resp->opcnt for
1043 * nfs4svc_encode_compoundres.
1044 *
Andy Adamson074fe892009-04-03 08:28:15 +03001045 */
Andy Adamsonabfabf82009-07-23 19:02:18 -04001046static __be32
1047nfsd4_enc_sequence_replay(struct nfsd4_compoundargs *args,
1048 struct nfsd4_compoundres *resp)
Andy Adamson074fe892009-04-03 08:28:15 +03001049{
Andy Adamsonabfabf82009-07-23 19:02:18 -04001050 struct nfsd4_op *op;
1051 struct nfsd4_slot *slot = resp->cstate.slot;
Andy Adamson074fe892009-04-03 08:28:15 +03001052
Andy Adamsonabfabf82009-07-23 19:02:18 -04001053 dprintk("--> %s resp->opcnt %d cachethis %u \n", __func__,
Andy Adamson557ce262009-08-28 08:45:04 -04001054 resp->opcnt, resp->cstate.slot->sl_cachethis);
Andy Adamsonabfabf82009-07-23 19:02:18 -04001055
1056 /* Encode the replayed sequence operation */
1057 op = &args->ops[resp->opcnt - 1];
1058 nfsd4_encode_operation(resp, op);
1059
1060 /* Return nfserr_retry_uncached_rep in next operation. */
Andy Adamson557ce262009-08-28 08:45:04 -04001061 if (args->opcnt > 1 && slot->sl_cachethis == 0) {
Andy Adamsonabfabf82009-07-23 19:02:18 -04001062 op = &args->ops[resp->opcnt++];
1063 op->status = nfserr_retry_uncached_rep;
1064 nfsd4_encode_operation(resp, op);
Andy Adamson074fe892009-04-03 08:28:15 +03001065 }
Andy Adamsonabfabf82009-07-23 19:02:18 -04001066 return op->status;
Andy Adamson074fe892009-04-03 08:28:15 +03001067}
1068
1069/*
Andy Adamson557ce262009-08-28 08:45:04 -04001070 * The sequence operation is not cached because we can use the slot and
1071 * session values.
Andy Adamson074fe892009-04-03 08:28:15 +03001072 */
1073__be32
Andy Adamsonbf864a32009-04-03 08:28:35 +03001074nfsd4_replay_cache_entry(struct nfsd4_compoundres *resp,
1075 struct nfsd4_sequence *seq)
Andy Adamson074fe892009-04-03 08:28:15 +03001076{
Andy Adamson557ce262009-08-28 08:45:04 -04001077 struct nfsd4_slot *slot = resp->cstate.slot;
Andy Adamson074fe892009-04-03 08:28:15 +03001078 __be32 status;
1079
Andy Adamson557ce262009-08-28 08:45:04 -04001080 dprintk("--> %s slot %p\n", __func__, slot);
Andy Adamson074fe892009-04-03 08:28:15 +03001081
Andy Adamsonabfabf82009-07-23 19:02:18 -04001082 /* Either returns 0 or nfserr_retry_uncached */
1083 status = nfsd4_enc_sequence_replay(resp->rqstp->rq_argp, resp);
1084 if (status == nfserr_retry_uncached_rep)
1085 return status;
Andy Adamson074fe892009-04-03 08:28:15 +03001086
Andy Adamson557ce262009-08-28 08:45:04 -04001087 /* The sequence operation has been encoded, cstate->datap set. */
1088 memcpy(resp->cstate.datap, slot->sl_data, slot->sl_datalen);
Andy Adamson074fe892009-04-03 08:28:15 +03001089
Andy Adamson557ce262009-08-28 08:45:04 -04001090 resp->opcnt = slot->sl_opcnt;
1091 resp->p = resp->cstate.datap + XDR_QUADLEN(slot->sl_datalen);
1092 status = slot->sl_status;
Andy Adamson074fe892009-04-03 08:28:15 +03001093
1094 return status;
1095}
1096
Andy Adamson0733d212009-04-03 08:28:01 +03001097/*
1098 * Set the exchange_id flags returned by the server.
1099 */
1100static void
1101nfsd4_set_ex_flags(struct nfs4_client *new, struct nfsd4_exchange_id *clid)
1102{
1103 /* pNFS is not supported */
1104 new->cl_exchange_flags |= EXCHGID4_FLAG_USE_NON_PNFS;
1105
1106 /* Referrals are supported, Migration is not. */
1107 new->cl_exchange_flags |= EXCHGID4_FLAG_SUPP_MOVED_REFER;
1108
1109 /* set the wire flags to return to client. */
1110 clid->flags = new->cl_exchange_flags;
1111}
1112
Al Virob37ad282006-10-19 23:28:59 -07001113__be32
Andy Adamson069b6ad2009-04-03 08:27:58 +03001114nfsd4_exchange_id(struct svc_rqst *rqstp,
1115 struct nfsd4_compound_state *cstate,
1116 struct nfsd4_exchange_id *exid)
1117{
Andy Adamson0733d212009-04-03 08:28:01 +03001118 struct nfs4_client *unconf, *conf, *new;
1119 int status;
1120 unsigned int strhashval;
1121 char dname[HEXDIR_LEN];
Jeff Layton363168b2009-08-14 12:57:56 -04001122 char addr_str[INET6_ADDRSTRLEN];
Andy Adamson0733d212009-04-03 08:28:01 +03001123 nfs4_verifier verf = exid->verifier;
Jeff Layton363168b2009-08-14 12:57:56 -04001124 struct sockaddr *sa = svc_addr(rqstp);
Andy Adamson0733d212009-04-03 08:28:01 +03001125
Jeff Layton363168b2009-08-14 12:57:56 -04001126 rpc_ntop(sa, addr_str, sizeof(addr_str));
Andy Adamson0733d212009-04-03 08:28:01 +03001127 dprintk("%s rqstp=%p exid=%p clname.len=%u clname.data=%p "
Jeff Layton363168b2009-08-14 12:57:56 -04001128 "ip_addr=%s flags %x, spa_how %d\n",
Andy Adamson0733d212009-04-03 08:28:01 +03001129 __func__, rqstp, exid, exid->clname.len, exid->clname.data,
Jeff Layton363168b2009-08-14 12:57:56 -04001130 addr_str, exid->flags, exid->spa_how);
Andy Adamson0733d212009-04-03 08:28:01 +03001131
1132 if (!check_name(exid->clname) || (exid->flags & ~EXCHGID4_FLAG_MASK_A))
1133 return nfserr_inval;
1134
1135 /* Currently only support SP4_NONE */
1136 switch (exid->spa_how) {
1137 case SP4_NONE:
1138 break;
1139 case SP4_SSV:
1140 return nfserr_encr_alg_unsupp;
1141 default:
1142 BUG(); /* checked by xdr code */
1143 case SP4_MACH_CRED:
1144 return nfserr_serverfault; /* no excuse :-/ */
1145 }
1146
1147 status = nfs4_make_rec_clidname(dname, &exid->clname);
1148
1149 if (status)
1150 goto error;
1151
1152 strhashval = clientstr_hashval(dname);
1153
1154 nfs4_lock_state();
1155 status = nfs_ok;
1156
Andy Adamsona1bcecd2009-04-03 08:28:05 +03001157 conf = find_confirmed_client_by_str(dname, strhashval, true);
Andy Adamson0733d212009-04-03 08:28:01 +03001158 if (conf) {
1159 if (!same_verf(&verf, &conf->cl_verifier)) {
1160 /* 18.35.4 case 8 */
1161 if (exid->flags & EXCHGID4_FLAG_UPD_CONFIRMED_REC_A) {
1162 status = nfserr_not_same;
1163 goto out;
1164 }
1165 /* Client reboot: destroy old state */
1166 expire_client(conf);
1167 goto out_new;
1168 }
1169 if (!same_creds(&conf->cl_cred, &rqstp->rq_cred)) {
1170 /* 18.35.4 case 9 */
1171 if (exid->flags & EXCHGID4_FLAG_UPD_CONFIRMED_REC_A) {
1172 status = nfserr_perm;
1173 goto out;
1174 }
1175 expire_client(conf);
1176 goto out_new;
1177 }
Andy Adamson0733d212009-04-03 08:28:01 +03001178 /*
1179 * Set bit when the owner id and verifier map to an already
1180 * confirmed client id (18.35.3).
1181 */
1182 exid->flags |= EXCHGID4_FLAG_CONFIRMED_R;
1183
1184 /*
1185 * Falling into 18.35.4 case 2, possible router replay.
1186 * Leave confirmed record intact and return same result.
1187 */
1188 copy_verf(conf, &verf);
1189 new = conf;
1190 goto out_copy;
Mike Sager6ddbbbf2009-06-16 04:20:47 +03001191 }
1192
1193 /* 18.35.4 case 7 */
1194 if (exid->flags & EXCHGID4_FLAG_UPD_CONFIRMED_REC_A) {
1195 status = nfserr_noent;
1196 goto out;
Andy Adamson0733d212009-04-03 08:28:01 +03001197 }
1198
Andy Adamsona1bcecd2009-04-03 08:28:05 +03001199 unconf = find_unconfirmed_client_by_str(dname, strhashval, true);
Andy Adamson0733d212009-04-03 08:28:01 +03001200 if (unconf) {
1201 /*
1202 * Possible retry or client restart. Per 18.35.4 case 4,
1203 * a new unconfirmed record should be generated regardless
1204 * of whether any properties have changed.
1205 */
1206 expire_client(unconf);
1207 }
1208
1209out_new:
1210 /* Normal case */
Ricardo Labiagab09333c2009-09-10 12:27:34 +03001211 new = create_client(exid->clname, dname, rqstp, &verf);
Andy Adamson0733d212009-04-03 08:28:01 +03001212 if (new == NULL) {
Andy Adamsonbdac86e2009-08-28 08:45:03 -04001213 status = nfserr_serverfault;
Andy Adamson0733d212009-04-03 08:28:01 +03001214 goto out;
1215 }
1216
Andy Adamson0733d212009-04-03 08:28:01 +03001217 gen_clid(new);
Andy Adamson0733d212009-04-03 08:28:01 +03001218 add_to_unconfirmed(new, strhashval);
1219out_copy:
1220 exid->clientid.cl_boot = new->cl_clientid.cl_boot;
1221 exid->clientid.cl_id = new->cl_clientid.cl_id;
1222
Andy Adamson38eb76a2009-04-03 08:28:32 +03001223 exid->seqid = 1;
Andy Adamson0733d212009-04-03 08:28:01 +03001224 nfsd4_set_ex_flags(new, exid);
1225
1226 dprintk("nfsd4_exchange_id seqid %d flags %x\n",
Andy Adamson49557cc2009-07-23 19:02:16 -04001227 new->cl_cs_slot.sl_seqid, new->cl_exchange_flags);
Andy Adamson0733d212009-04-03 08:28:01 +03001228 status = nfs_ok;
1229
1230out:
1231 nfs4_unlock_state();
1232error:
1233 dprintk("nfsd4_exchange_id returns %d\n", ntohl(status));
1234 return status;
Andy Adamson069b6ad2009-04-03 08:27:58 +03001235}
1236
Benny Halevyb85d4c02009-04-03 08:28:08 +03001237static int
Andy Adamson88e588d2009-07-23 19:02:15 -04001238check_slot_seqid(u32 seqid, u32 slot_seqid, int slot_inuse)
Benny Halevyb85d4c02009-04-03 08:28:08 +03001239{
Andy Adamson88e588d2009-07-23 19:02:15 -04001240 dprintk("%s enter. seqid %d slot_seqid %d\n", __func__, seqid,
1241 slot_seqid);
Benny Halevyb85d4c02009-04-03 08:28:08 +03001242
1243 /* The slot is in use, and no response has been sent. */
Andy Adamson88e588d2009-07-23 19:02:15 -04001244 if (slot_inuse) {
1245 if (seqid == slot_seqid)
Benny Halevyb85d4c02009-04-03 08:28:08 +03001246 return nfserr_jukebox;
1247 else
1248 return nfserr_seq_misordered;
1249 }
1250 /* Normal */
Andy Adamson88e588d2009-07-23 19:02:15 -04001251 if (likely(seqid == slot_seqid + 1))
Benny Halevyb85d4c02009-04-03 08:28:08 +03001252 return nfs_ok;
1253 /* Replay */
Andy Adamson88e588d2009-07-23 19:02:15 -04001254 if (seqid == slot_seqid)
Benny Halevyb85d4c02009-04-03 08:28:08 +03001255 return nfserr_replay_cache;
1256 /* Wraparound */
Andy Adamson88e588d2009-07-23 19:02:15 -04001257 if (seqid == 1 && (slot_seqid + 1) == 0)
Benny Halevyb85d4c02009-04-03 08:28:08 +03001258 return nfs_ok;
1259 /* Misordered replay or misordered new request */
1260 return nfserr_seq_misordered;
1261}
1262
Andy Adamson49557cc2009-07-23 19:02:16 -04001263/*
1264 * Cache the create session result into the create session single DRC
1265 * slot cache by saving the xdr structure. sl_seqid has been set.
1266 * Do this for solo or embedded create session operations.
1267 */
1268static void
1269nfsd4_cache_create_session(struct nfsd4_create_session *cr_ses,
1270 struct nfsd4_clid_slot *slot, int nfserr)
1271{
1272 slot->sl_status = nfserr;
1273 memcpy(&slot->sl_cr_ses, cr_ses, sizeof(*cr_ses));
1274}
1275
1276static __be32
1277nfsd4_replay_create_session(struct nfsd4_create_session *cr_ses,
1278 struct nfsd4_clid_slot *slot)
1279{
1280 memcpy(cr_ses, &slot->sl_cr_ses, sizeof(*cr_ses));
1281 return slot->sl_status;
1282}
1283
Andy Adamson069b6ad2009-04-03 08:27:58 +03001284__be32
1285nfsd4_create_session(struct svc_rqst *rqstp,
1286 struct nfsd4_compound_state *cstate,
1287 struct nfsd4_create_session *cr_ses)
1288{
Jeff Layton363168b2009-08-14 12:57:56 -04001289 struct sockaddr *sa = svc_addr(rqstp);
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001290 struct nfs4_client *conf, *unconf;
Andy Adamson49557cc2009-07-23 19:02:16 -04001291 struct nfsd4_clid_slot *cs_slot = NULL;
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001292 int status = 0;
1293
1294 nfs4_lock_state();
1295 unconf = find_unconfirmed_client(&cr_ses->clientid);
1296 conf = find_confirmed_client(&cr_ses->clientid);
1297
1298 if (conf) {
Andy Adamson49557cc2009-07-23 19:02:16 -04001299 cs_slot = &conf->cl_cs_slot;
1300 status = check_slot_seqid(cr_ses->seqid, cs_slot->sl_seqid, 0);
Andy Adamson38eb76a2009-04-03 08:28:32 +03001301 if (status == nfserr_replay_cache) {
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001302 dprintk("Got a create_session replay! seqid= %d\n",
Andy Adamson49557cc2009-07-23 19:02:16 -04001303 cs_slot->sl_seqid);
Andy Adamson38eb76a2009-04-03 08:28:32 +03001304 /* Return the cached reply status */
Andy Adamson49557cc2009-07-23 19:02:16 -04001305 status = nfsd4_replay_create_session(cr_ses, cs_slot);
Andy Adamson38eb76a2009-04-03 08:28:32 +03001306 goto out;
Andy Adamson49557cc2009-07-23 19:02:16 -04001307 } else if (cr_ses->seqid != cs_slot->sl_seqid + 1) {
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001308 status = nfserr_seq_misordered;
1309 dprintk("Sequence misordered!\n");
1310 dprintk("Expected seqid= %d but got seqid= %d\n",
Andy Adamson49557cc2009-07-23 19:02:16 -04001311 cs_slot->sl_seqid, cr_ses->seqid);
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001312 goto out;
1313 }
Andy Adamson49557cc2009-07-23 19:02:16 -04001314 cs_slot->sl_seqid++;
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001315 } else if (unconf) {
1316 if (!same_creds(&unconf->cl_cred, &rqstp->rq_cred) ||
Jeff Layton363168b2009-08-14 12:57:56 -04001317 !rpc_cmp_addr(sa, (struct sockaddr *) &unconf->cl_addr)) {
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001318 status = nfserr_clid_inuse;
1319 goto out;
1320 }
1321
Andy Adamson49557cc2009-07-23 19:02:16 -04001322 cs_slot = &unconf->cl_cs_slot;
1323 status = check_slot_seqid(cr_ses->seqid, cs_slot->sl_seqid, 0);
Andy Adamson38eb76a2009-04-03 08:28:32 +03001324 if (status) {
1325 /* an unconfirmed replay returns misordered */
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001326 status = nfserr_seq_misordered;
Andy Adamson49557cc2009-07-23 19:02:16 -04001327 goto out_cache;
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001328 }
1329
Andy Adamson49557cc2009-07-23 19:02:16 -04001330 cs_slot->sl_seqid++; /* from 0 to 1 */
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001331 move_to_confirmed(unconf);
1332
1333 /*
1334 * We do not support RDMA or persistent sessions
1335 */
1336 cr_ses->flags &= ~SESSION4_PERSIST;
1337 cr_ses->flags &= ~SESSION4_RDMA;
1338
Andy Adamson38524ab2009-09-10 12:25:59 +03001339 if (cr_ses->flags & SESSION4_BACK_CHAN) {
1340 unconf->cl_cb_xprt = rqstp->rq_xprt;
1341 svc_xprt_get(unconf->cl_cb_xprt);
1342 rpc_copy_addr(
1343 (struct sockaddr *)&unconf->cl_cb_conn.cb_addr,
1344 sa);
1345 unconf->cl_cb_conn.cb_addrlen = svc_addr_len(sa);
1346 unconf->cl_cb_conn.cb_minorversion =
1347 cstate->minorversion;
1348 unconf->cl_cb_conn.cb_prog = cr_ses->callback_prog;
Ricardo Labiaga2a1d1b52009-09-10 12:26:38 +03001349 unconf->cl_cb_seq_nr = 1;
Andy Adamson38524ab2009-09-10 12:25:59 +03001350 nfsd4_probe_callback(unconf);
1351 }
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001352 conf = unconf;
1353 } else {
1354 status = nfserr_stale_clientid;
1355 goto out;
1356 }
1357
1358 status = alloc_init_session(rqstp, conf, cr_ses);
1359 if (status)
1360 goto out;
1361
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001362 memcpy(cr_ses->sessionid.data, conf->cl_sessionid.data,
1363 NFS4_MAX_SESSIONID_LEN);
Andy Adamson49557cc2009-07-23 19:02:16 -04001364 cr_ses->seqid = cs_slot->sl_seqid;
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001365
Andy Adamson49557cc2009-07-23 19:02:16 -04001366out_cache:
1367 /* cache solo and embedded create sessions under the state lock */
1368 nfsd4_cache_create_session(cr_ses, cs_slot, status);
Andy Adamsonec6b5d72009-04-03 08:28:28 +03001369out:
1370 nfs4_unlock_state();
1371 dprintk("%s returns %d\n", __func__, ntohl(status));
1372 return status;
Andy Adamson069b6ad2009-04-03 08:27:58 +03001373}
1374
1375__be32
1376nfsd4_destroy_session(struct svc_rqst *r,
1377 struct nfsd4_compound_state *cstate,
1378 struct nfsd4_destroy_session *sessionid)
1379{
Benny Halevye10e0cf2009-04-03 08:28:38 +03001380 struct nfsd4_session *ses;
1381 u32 status = nfserr_badsession;
1382
1383 /* Notes:
1384 * - The confirmed nfs4_client->cl_sessionid holds destroyed sessinid
1385 * - Should we return nfserr_back_chan_busy if waiting for
1386 * callbacks on to-be-destroyed session?
1387 * - Do we need to clear any callback info from previous session?
1388 */
1389
1390 dump_sessionid(__func__, &sessionid->sessionid);
1391 spin_lock(&sessionid_lock);
1392 ses = find_in_sessionid_hashtbl(&sessionid->sessionid);
1393 if (!ses) {
1394 spin_unlock(&sessionid_lock);
1395 goto out;
1396 }
1397
1398 unhash_session(ses);
1399 spin_unlock(&sessionid_lock);
1400
1401 /* wait for callbacks */
1402 shutdown_callback_client(ses->se_client);
1403 nfsd4_put_session(ses);
1404 status = nfs_ok;
1405out:
1406 dprintk("%s returns %d\n", __func__, ntohl(status));
1407 return status;
Andy Adamson069b6ad2009-04-03 08:27:58 +03001408}
1409
1410__be32
Benny Halevyb85d4c02009-04-03 08:28:08 +03001411nfsd4_sequence(struct svc_rqst *rqstp,
Andy Adamson069b6ad2009-04-03 08:27:58 +03001412 struct nfsd4_compound_state *cstate,
1413 struct nfsd4_sequence *seq)
1414{
Andy Adamsonf9bb94c2009-04-03 08:28:12 +03001415 struct nfsd4_compoundres *resp = rqstp->rq_resp;
Benny Halevyb85d4c02009-04-03 08:28:08 +03001416 struct nfsd4_session *session;
1417 struct nfsd4_slot *slot;
1418 int status;
1419
Andy Adamsonf9bb94c2009-04-03 08:28:12 +03001420 if (resp->opcnt != 1)
1421 return nfserr_sequence_pos;
1422
Benny Halevyb85d4c02009-04-03 08:28:08 +03001423 spin_lock(&sessionid_lock);
1424 status = nfserr_badsession;
1425 session = find_in_sessionid_hashtbl(&seq->sessionid);
1426 if (!session)
1427 goto out;
1428
1429 status = nfserr_badslot;
Alexandros Batsakis6c18ba92009-06-16 04:19:13 +03001430 if (seq->slotid >= session->se_fchannel.maxreqs)
Benny Halevyb85d4c02009-04-03 08:28:08 +03001431 goto out;
1432
Andy Adamson557ce262009-08-28 08:45:04 -04001433 slot = session->se_slots[seq->slotid];
Benny Halevyb85d4c02009-04-03 08:28:08 +03001434 dprintk("%s: slotid %d\n", __func__, seq->slotid);
1435
Andy Adamsona8dfdae2009-08-28 08:45:02 -04001436 /* We do not negotiate the number of slots yet, so set the
1437 * maxslots to the session maxreqs which is used to encode
1438 * sr_highest_slotid and the sr_target_slot id to maxslots */
1439 seq->maxslots = session->se_fchannel.maxreqs;
1440
Andy Adamson88e588d2009-07-23 19:02:15 -04001441 status = check_slot_seqid(seq->seqid, slot->sl_seqid, slot->sl_inuse);
Benny Halevyb85d4c02009-04-03 08:28:08 +03001442 if (status == nfserr_replay_cache) {
1443 cstate->slot = slot;
1444 cstate->session = session;
Andy Adamsonda3846a2009-04-03 08:28:22 +03001445 /* Return the cached reply status and set cstate->status
Andy Adamson557ce262009-08-28 08:45:04 -04001446 * for nfsd4_proc_compound processing */
Andy Adamsonbf864a32009-04-03 08:28:35 +03001447 status = nfsd4_replay_cache_entry(resp, seq);
Andy Adamsonda3846a2009-04-03 08:28:22 +03001448 cstate->status = nfserr_replay_cache;
Benny Halevyaaf84eb2009-08-20 03:21:56 +03001449 goto out;
Benny Halevyb85d4c02009-04-03 08:28:08 +03001450 }
1451 if (status)
1452 goto out;
1453
1454 /* Success! bump slot seqid */
1455 slot->sl_inuse = true;
1456 slot->sl_seqid = seq->seqid;
Andy Adamson557ce262009-08-28 08:45:04 -04001457 slot->sl_cachethis = seq->cachethis;
Benny Halevyb85d4c02009-04-03 08:28:08 +03001458
1459 cstate->slot = slot;
1460 cstate->session = session;
1461
Benny Halevyaaf84eb2009-08-20 03:21:56 +03001462 /* Hold a session reference until done processing the compound:
Benny Halevyb85d4c02009-04-03 08:28:08 +03001463 * nfsd4_put_session called only if the cstate slot is set.
1464 */
Benny Halevyb85d4c02009-04-03 08:28:08 +03001465 nfsd4_get_session(session);
1466out:
1467 spin_unlock(&sessionid_lock);
Benny Halevyaaf84eb2009-08-20 03:21:56 +03001468 /* Renew the clientid on success and on replay */
1469 if (cstate->session) {
1470 nfs4_lock_state();
1471 renew_client(session->se_client);
1472 nfs4_unlock_state();
1473 }
Benny Halevyb85d4c02009-04-03 08:28:08 +03001474 dprintk("%s: return %d\n", __func__, ntohl(status));
1475 return status;
Andy Adamson069b6ad2009-04-03 08:27:58 +03001476}
1477
1478__be32
J.Bruce Fieldsb5914802006-12-13 00:35:38 -08001479nfsd4_setclientid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
1480 struct nfsd4_setclientid *setclid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001481{
Jeff Layton363168b2009-08-14 12:57:56 -04001482 struct sockaddr *sa = svc_addr(rqstp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001483 struct xdr_netobj clname = {
1484 .len = setclid->se_namelen,
1485 .data = setclid->se_name,
1486 };
1487 nfs4_verifier clverifier = setclid->se_verf;
1488 unsigned int strhashval;
NeilBrown28ce6052005-06-23 22:03:56 -07001489 struct nfs4_client *conf, *unconf, *new;
Al Virob37ad282006-10-19 23:28:59 -07001490 __be32 status;
NeilBrowna55370a2005-06-23 22:03:52 -07001491 char dname[HEXDIR_LEN];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001492
Linus Torvalds1da177e2005-04-16 15:20:36 -07001493 if (!check_name(clname))
Neil Brown73aea4e2005-09-13 01:25:39 -07001494 return nfserr_inval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001495
NeilBrowna55370a2005-06-23 22:03:52 -07001496 status = nfs4_make_rec_clidname(dname, &clname);
1497 if (status)
Neil Brown73aea4e2005-09-13 01:25:39 -07001498 return status;
NeilBrowna55370a2005-06-23 22:03:52 -07001499
Linus Torvalds1da177e2005-04-16 15:20:36 -07001500 /*
1501 * XXX The Duplicate Request Cache (DRC) has been checked (??)
1502 * We get here on a DRC miss.
1503 */
1504
NeilBrowna55370a2005-06-23 22:03:52 -07001505 strhashval = clientstr_hashval(dname);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001506
Linus Torvalds1da177e2005-04-16 15:20:36 -07001507 nfs4_lock_state();
Andy Adamsona1bcecd2009-04-03 08:28:05 +03001508 conf = find_confirmed_client_by_str(dname, strhashval, false);
NeilBrown28ce6052005-06-23 22:03:56 -07001509 if (conf) {
J. Bruce Fieldsa186e762007-11-20 16:11:27 -05001510 /* RFC 3530 14.2.33 CASE 0: */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001511 status = nfserr_clid_inuse;
J. Bruce Fields026722c2009-03-18 15:06:26 -04001512 if (!same_creds(&conf->cl_cred, &rqstp->rq_cred)) {
Jeff Layton363168b2009-08-14 12:57:56 -04001513 char addr_str[INET6_ADDRSTRLEN];
1514 rpc_ntop((struct sockaddr *) &conf->cl_addr, addr_str,
1515 sizeof(addr_str));
1516 dprintk("NFSD: setclientid: string in use by client "
1517 "at %s\n", addr_str);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001518 goto out;
1519 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001520 }
J. Bruce Fieldsa186e762007-11-20 16:11:27 -05001521 /*
1522 * section 14.2.33 of RFC 3530 (under the heading "IMPLEMENTATION")
1523 * has a description of SETCLIENTID request processing consisting
1524 * of 5 bullet points, labeled as CASE0 - CASE4 below.
1525 */
Andy Adamsona1bcecd2009-04-03 08:28:05 +03001526 unconf = find_unconfirmed_client_by_str(dname, strhashval, false);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001527 status = nfserr_resource;
1528 if (!conf) {
J. Bruce Fieldsa186e762007-11-20 16:11:27 -05001529 /*
1530 * RFC 3530 14.2.33 CASE 4:
1531 * placed first, because it is the normal case
Linus Torvalds1da177e2005-04-16 15:20:36 -07001532 */
1533 if (unconf)
1534 expire_client(unconf);
Ricardo Labiagab09333c2009-09-10 12:27:34 +03001535 new = create_client(clname, dname, rqstp, &clverifier);
NeilBrowna55370a2005-06-23 22:03:52 -07001536 if (new == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001537 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001538 gen_clid(new);
J. Bruce Fields599e0a22007-07-26 17:04:54 -04001539 } else if (same_verf(&conf->cl_verifier, &clverifier)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001540 /*
J. Bruce Fieldsa186e762007-11-20 16:11:27 -05001541 * RFC 3530 14.2.33 CASE 1:
1542 * probable callback update
Linus Torvalds1da177e2005-04-16 15:20:36 -07001543 */
NeilBrown31f4a6c2005-06-23 22:04:06 -07001544 if (unconf) {
1545 /* Note this is removing unconfirmed {*x***},
1546 * which is stronger than RFC recommended {vxc**}.
1547 * This has the advantage that there is at most
1548 * one {*x***} in either list at any time.
1549 */
1550 expire_client(unconf);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001551 }
Ricardo Labiagab09333c2009-09-10 12:27:34 +03001552 new = create_client(clname, dname, rqstp, &clverifier);
NeilBrowna55370a2005-06-23 22:03:52 -07001553 if (new == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001554 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001555 copy_clid(new, conf);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001556 } else if (!unconf) {
1557 /*
J. Bruce Fieldsa186e762007-11-20 16:11:27 -05001558 * RFC 3530 14.2.33 CASE 2:
1559 * probable client reboot; state will be removed if
1560 * confirmed.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001561 */
Ricardo Labiagab09333c2009-09-10 12:27:34 +03001562 new = create_client(clname, dname, rqstp, &clverifier);
NeilBrowna55370a2005-06-23 22:03:52 -07001563 if (new == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001564 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001565 gen_clid(new);
J. Bruce Fields49ba8782007-11-19 19:09:50 -05001566 } else {
J. Bruce Fieldsa186e762007-11-20 16:11:27 -05001567 /*
1568 * RFC 3530 14.2.33 CASE 3:
1569 * probable client reboot; state will be removed if
1570 * confirmed.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001571 */
1572 expire_client(unconf);
Ricardo Labiagab09333c2009-09-10 12:27:34 +03001573 new = create_client(clname, dname, rqstp, &clverifier);
NeilBrowna55370a2005-06-23 22:03:52 -07001574 if (new == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001575 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001576 gen_clid(new);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001577 }
Jeff Laytonfbf46652009-08-14 12:57:59 -04001578 gen_callback(new, setclid, rpc_get_scope_id(sa));
J. Bruce Fieldsc175b832007-08-09 18:34:32 -04001579 add_to_unconfirmed(new, strhashval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001580 setclid->se_clientid.cl_boot = new->cl_clientid.cl_boot;
1581 setclid->se_clientid.cl_id = new->cl_clientid.cl_id;
1582 memcpy(setclid->se_confirm.data, new->cl_confirm.data, sizeof(setclid->se_confirm.data));
1583 status = nfs_ok;
1584out:
1585 nfs4_unlock_state();
1586 return status;
1587}
1588
1589
1590/*
J. Bruce Fieldsa186e762007-11-20 16:11:27 -05001591 * Section 14.2.34 of RFC 3530 (under the heading "IMPLEMENTATION") has
1592 * a description of SETCLIENTID_CONFIRM request processing consisting of 4
1593 * bullets, labeled as CASE1 - CASE4 below.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001594 */
Al Virob37ad282006-10-19 23:28:59 -07001595__be32
J.Bruce Fieldsb5914802006-12-13 00:35:38 -08001596nfsd4_setclientid_confirm(struct svc_rqst *rqstp,
1597 struct nfsd4_compound_state *cstate,
1598 struct nfsd4_setclientid_confirm *setclientid_confirm)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001599{
Jeff Layton363168b2009-08-14 12:57:56 -04001600 struct sockaddr *sa = svc_addr(rqstp);
NeilBrown21ab45a2005-06-23 22:04:14 -07001601 struct nfs4_client *conf, *unconf;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001602 nfs4_verifier confirm = setclientid_confirm->sc_confirm;
1603 clientid_t * clid = &setclientid_confirm->sc_clientid;
Al Virob37ad282006-10-19 23:28:59 -07001604 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001605
1606 if (STALE_CLIENTID(clid))
1607 return nfserr_stale_clientid;
1608 /*
1609 * XXX The Duplicate Request Cache (DRC) has been checked (??)
1610 * We get here on a DRC miss.
1611 */
1612
1613 nfs4_lock_state();
NeilBrown21ab45a2005-06-23 22:04:14 -07001614
1615 conf = find_confirmed_client(clid);
1616 unconf = find_unconfirmed_client(clid);
1617
1618 status = nfserr_clid_inuse;
Jeff Layton363168b2009-08-14 12:57:56 -04001619 if (conf && !rpc_cmp_addr((struct sockaddr *) &conf->cl_addr, sa))
NeilBrown21ab45a2005-06-23 22:04:14 -07001620 goto out;
Jeff Layton363168b2009-08-14 12:57:56 -04001621 if (unconf && !rpc_cmp_addr((struct sockaddr *) &unconf->cl_addr, sa))
NeilBrown21ab45a2005-06-23 22:04:14 -07001622 goto out;
1623
J. Bruce Fieldsa186e762007-11-20 16:11:27 -05001624 /*
1625 * section 14.2.34 of RFC 3530 has a description of
1626 * SETCLIENTID_CONFIRM request processing consisting
1627 * of 4 bullet points, labeled as CASE1 - CASE4 below.
1628 */
J. Bruce Fields366e0c12007-11-20 15:54:10 -05001629 if (conf && unconf && same_verf(&confirm, &unconf->cl_confirm)) {
J. Bruce Fieldsa186e762007-11-20 16:11:27 -05001630 /*
1631 * RFC 3530 14.2.34 CASE 1:
1632 * callback update
1633 */
J. Bruce Fields599e0a22007-07-26 17:04:54 -04001634 if (!same_creds(&conf->cl_cred, &unconf->cl_cred))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001635 status = nfserr_clid_inuse;
1636 else {
NeilBrown1a69c172005-06-23 22:04:08 -07001637 /* XXX: We just turn off callbacks until we can handle
1638 * change request correctly. */
J. Bruce Fieldsc237dc02009-04-29 19:09:19 -04001639 atomic_set(&conf->cl_cb_conn.cb_set, 0);
NeilBrown1a69c172005-06-23 22:04:08 -07001640 expire_client(unconf);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001641 status = nfs_ok;
NeilBrown1a69c172005-06-23 22:04:08 -07001642
Linus Torvalds1da177e2005-04-16 15:20:36 -07001643 }
J. Bruce Fieldsf3aba4e2007-11-20 16:52:07 -05001644 } else if (conf && !unconf) {
J. Bruce Fieldsa186e762007-11-20 16:11:27 -05001645 /*
1646 * RFC 3530 14.2.34 CASE 2:
1647 * probable retransmitted request; play it safe and
1648 * do nothing.
NeilBrown7c79f732005-06-23 22:04:13 -07001649 */
J. Bruce Fields599e0a22007-07-26 17:04:54 -04001650 if (!same_creds(&conf->cl_cred, &rqstp->rq_cred))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001651 status = nfserr_clid_inuse;
NeilBrown21ab45a2005-06-23 22:04:14 -07001652 else
Linus Torvalds1da177e2005-04-16 15:20:36 -07001653 status = nfs_ok;
NeilBrown7c79f732005-06-23 22:04:13 -07001654 } else if (!conf && unconf
J. Bruce Fields599e0a22007-07-26 17:04:54 -04001655 && same_verf(&unconf->cl_confirm, &confirm)) {
J. Bruce Fieldsa186e762007-11-20 16:11:27 -05001656 /*
1657 * RFC 3530 14.2.34 CASE 3:
1658 * Normal case; new or rebooted client:
NeilBrown7c79f732005-06-23 22:04:13 -07001659 */
J. Bruce Fields599e0a22007-07-26 17:04:54 -04001660 if (!same_creds(&unconf->cl_cred, &rqstp->rq_cred)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001661 status = nfserr_clid_inuse;
1662 } else {
NeilBrown1a69c172005-06-23 22:04:08 -07001663 unsigned int hash =
1664 clientstr_hashval(unconf->cl_recdir);
1665 conf = find_confirmed_client_by_str(unconf->cl_recdir,
Andy Adamsona1bcecd2009-04-03 08:28:05 +03001666 hash, false);
NeilBrown1a69c172005-06-23 22:04:08 -07001667 if (conf) {
NeilBrownc7b9a452005-06-23 22:04:30 -07001668 nfsd4_remove_clid_dir(conf);
NeilBrown1a69c172005-06-23 22:04:08 -07001669 expire_client(conf);
1670 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001671 move_to_confirmed(unconf);
NeilBrown21ab45a2005-06-23 22:04:14 -07001672 conf = unconf;
J. Bruce Fields46f8a642007-11-22 13:54:18 -05001673 nfsd4_probe_callback(conf);
NeilBrown1a69c172005-06-23 22:04:08 -07001674 status = nfs_ok;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001675 }
J. Bruce Fields599e0a22007-07-26 17:04:54 -04001676 } else if ((!conf || (conf && !same_verf(&conf->cl_confirm, &confirm)))
1677 && (!unconf || (unconf && !same_verf(&unconf->cl_confirm,
NeilBrown7c79f732005-06-23 22:04:13 -07001678 &confirm)))) {
J. Bruce Fieldsa186e762007-11-20 16:11:27 -05001679 /*
1680 * RFC 3530 14.2.34 CASE 4:
1681 * Client probably hasn't noticed that we rebooted yet.
NeilBrown7c79f732005-06-23 22:04:13 -07001682 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001683 status = nfserr_stale_clientid;
NeilBrown7c79f732005-06-23 22:04:13 -07001684 } else {
NeilBrown08e89872005-06-23 22:04:11 -07001685 /* check that we have hit one of the cases...*/
1686 status = nfserr_clid_inuse;
1687 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001688out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001689 nfs4_unlock_state();
1690 return status;
1691}
1692
Linus Torvalds1da177e2005-04-16 15:20:36 -07001693/* OPEN Share state helper functions */
1694static inline struct nfs4_file *
1695alloc_init_file(struct inode *ino)
1696{
1697 struct nfs4_file *fp;
1698 unsigned int hashval = file_hashval(ino);
1699
NeilBrowne60d4392005-06-23 22:03:01 -07001700 fp = kmem_cache_alloc(file_slab, GFP_KERNEL);
1701 if (fp) {
J. Bruce Fields8b671b82009-02-22 14:51:34 -08001702 atomic_set(&fp->fi_ref, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001703 INIT_LIST_HEAD(&fp->fi_hash);
NeilBrown8beefa22005-06-23 22:03:08 -07001704 INIT_LIST_HEAD(&fp->fi_stateids);
1705 INIT_LIST_HEAD(&fp->fi_delegations);
J. Bruce Fields8b671b82009-02-22 14:51:34 -08001706 spin_lock(&recall_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001707 list_add(&fp->fi_hash, &file_hashtbl[hashval]);
J. Bruce Fields8b671b82009-02-22 14:51:34 -08001708 spin_unlock(&recall_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001709 fp->fi_inode = igrab(ino);
1710 fp->fi_id = current_fileid++;
Meelap Shah47f99402007-07-17 04:04:40 -07001711 fp->fi_had_conflict = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001712 return fp;
1713 }
1714 return NULL;
1715}
1716
1717static void
Christoph Lametere18b8902006-12-06 20:33:20 -08001718nfsd4_free_slab(struct kmem_cache **slab)
NeilBrowne60d4392005-06-23 22:03:01 -07001719{
NeilBrowne60d4392005-06-23 22:03:01 -07001720 if (*slab == NULL)
1721 return;
Alexey Dobriyan1a1d92c2006-09-27 01:49:40 -07001722 kmem_cache_destroy(*slab);
NeilBrowne60d4392005-06-23 22:03:01 -07001723 *slab = NULL;
NeilBrowne60d4392005-06-23 22:03:01 -07001724}
1725
J. Bruce Fieldse8ff2a82007-08-01 15:30:59 -04001726void
NeilBrowne60d4392005-06-23 22:03:01 -07001727nfsd4_free_slabs(void)
1728{
1729 nfsd4_free_slab(&stateowner_slab);
1730 nfsd4_free_slab(&file_slab);
NeilBrown5ac049a2005-06-23 22:03:03 -07001731 nfsd4_free_slab(&stateid_slab);
NeilBrown5b2d21c2005-06-23 22:03:04 -07001732 nfsd4_free_slab(&deleg_slab);
NeilBrowne60d4392005-06-23 22:03:01 -07001733}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001734
1735static int
1736nfsd4_init_slabs(void)
1737{
1738 stateowner_slab = kmem_cache_create("nfsd4_stateowners",
Paul Mundt20c2df82007-07-20 10:11:58 +09001739 sizeof(struct nfs4_stateowner), 0, 0, NULL);
NeilBrowne60d4392005-06-23 22:03:01 -07001740 if (stateowner_slab == NULL)
1741 goto out_nomem;
1742 file_slab = kmem_cache_create("nfsd4_files",
Paul Mundt20c2df82007-07-20 10:11:58 +09001743 sizeof(struct nfs4_file), 0, 0, NULL);
NeilBrowne60d4392005-06-23 22:03:01 -07001744 if (file_slab == NULL)
1745 goto out_nomem;
NeilBrown5ac049a2005-06-23 22:03:03 -07001746 stateid_slab = kmem_cache_create("nfsd4_stateids",
Paul Mundt20c2df82007-07-20 10:11:58 +09001747 sizeof(struct nfs4_stateid), 0, 0, NULL);
NeilBrown5ac049a2005-06-23 22:03:03 -07001748 if (stateid_slab == NULL)
1749 goto out_nomem;
NeilBrown5b2d21c2005-06-23 22:03:04 -07001750 deleg_slab = kmem_cache_create("nfsd4_delegations",
Paul Mundt20c2df82007-07-20 10:11:58 +09001751 sizeof(struct nfs4_delegation), 0, 0, NULL);
NeilBrown5b2d21c2005-06-23 22:03:04 -07001752 if (deleg_slab == NULL)
1753 goto out_nomem;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001754 return 0;
NeilBrowne60d4392005-06-23 22:03:01 -07001755out_nomem:
1756 nfsd4_free_slabs();
1757 dprintk("nfsd4: out of memory while initializing nfsv4\n");
1758 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001759}
1760
1761void
1762nfs4_free_stateowner(struct kref *kref)
1763{
1764 struct nfs4_stateowner *sop =
1765 container_of(kref, struct nfs4_stateowner, so_ref);
1766 kfree(sop->so_owner.data);
1767 kmem_cache_free(stateowner_slab, sop);
1768}
1769
1770static inline struct nfs4_stateowner *
1771alloc_stateowner(struct xdr_netobj *owner)
1772{
1773 struct nfs4_stateowner *sop;
1774
1775 if ((sop = kmem_cache_alloc(stateowner_slab, GFP_KERNEL))) {
1776 if ((sop->so_owner.data = kmalloc(owner->len, GFP_KERNEL))) {
1777 memcpy(sop->so_owner.data, owner->data, owner->len);
1778 sop->so_owner.len = owner->len;
1779 kref_init(&sop->so_ref);
1780 return sop;
1781 }
1782 kmem_cache_free(stateowner_slab, sop);
1783 }
1784 return NULL;
1785}
1786
1787static struct nfs4_stateowner *
1788alloc_init_open_stateowner(unsigned int strhashval, struct nfs4_client *clp, struct nfsd4_open *open) {
1789 struct nfs4_stateowner *sop;
1790 struct nfs4_replay *rp;
1791 unsigned int idhashval;
1792
1793 if (!(sop = alloc_stateowner(&open->op_owner)))
1794 return NULL;
1795 idhashval = ownerid_hashval(current_ownerid);
1796 INIT_LIST_HEAD(&sop->so_idhash);
1797 INIT_LIST_HEAD(&sop->so_strhash);
1798 INIT_LIST_HEAD(&sop->so_perclient);
NeilBrownea1da632005-06-23 22:04:17 -07001799 INIT_LIST_HEAD(&sop->so_stateids);
1800 INIT_LIST_HEAD(&sop->so_perstateid); /* not used */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001801 INIT_LIST_HEAD(&sop->so_close_lru);
1802 sop->so_time = 0;
1803 list_add(&sop->so_idhash, &ownerid_hashtbl[idhashval]);
1804 list_add(&sop->so_strhash, &ownerstr_hashtbl[strhashval]);
NeilBrownea1da632005-06-23 22:04:17 -07001805 list_add(&sop->so_perclient, &clp->cl_openowners);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001806 sop->so_is_open_owner = 1;
1807 sop->so_id = current_ownerid++;
1808 sop->so_client = clp;
1809 sop->so_seqid = open->op_seqid;
1810 sop->so_confirmed = 0;
1811 rp = &sop->so_replay;
Al Virode1ae282006-01-18 17:43:47 -08001812 rp->rp_status = nfserr_serverfault;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001813 rp->rp_buflen = 0;
1814 rp->rp_buf = rp->rp_ibuf;
1815 return sop;
1816}
1817
Linus Torvalds1da177e2005-04-16 15:20:36 -07001818static inline void
1819init_stateid(struct nfs4_stateid *stp, struct nfs4_file *fp, struct nfsd4_open *open) {
1820 struct nfs4_stateowner *sop = open->op_stateowner;
1821 unsigned int hashval = stateid_hashval(sop->so_id, fp->fi_id);
1822
1823 INIT_LIST_HEAD(&stp->st_hash);
NeilBrownea1da632005-06-23 22:04:17 -07001824 INIT_LIST_HEAD(&stp->st_perstateowner);
1825 INIT_LIST_HEAD(&stp->st_lockowners);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001826 INIT_LIST_HEAD(&stp->st_perfile);
1827 list_add(&stp->st_hash, &stateid_hashtbl[hashval]);
NeilBrownea1da632005-06-23 22:04:17 -07001828 list_add(&stp->st_perstateowner, &sop->so_stateids);
NeilBrown8beefa22005-06-23 22:03:08 -07001829 list_add(&stp->st_perfile, &fp->fi_stateids);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001830 stp->st_stateowner = sop;
NeilBrown13cd2182005-06-23 22:03:10 -07001831 get_nfs4_file(fp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001832 stp->st_file = fp;
Bian Naimeng78155ed2009-04-22 18:25:37 +08001833 stp->st_stateid.si_boot = get_seconds();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001834 stp->st_stateid.si_stateownerid = sop->so_id;
1835 stp->st_stateid.si_fileid = fp->fi_id;
1836 stp->st_stateid.si_generation = 0;
1837 stp->st_access_bmap = 0;
1838 stp->st_deny_bmap = 0;
Andy Adamson84459a12009-04-03 08:28:56 +03001839 __set_bit(open->op_share_access & ~NFS4_SHARE_WANT_MASK,
1840 &stp->st_access_bmap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001841 __set_bit(open->op_share_deny, &stp->st_deny_bmap);
NeilBrown4c4cd222005-07-07 17:59:27 -07001842 stp->st_openstp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001843}
1844
1845static void
Linus Torvalds1da177e2005-04-16 15:20:36 -07001846move_to_close_lru(struct nfs4_stateowner *sop)
1847{
1848 dprintk("NFSD: move_to_close_lru nfs4_stateowner %p\n", sop);
1849
NeilBrown358dd552006-04-10 22:55:42 -07001850 list_move_tail(&sop->so_close_lru, &close_lru);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001851 sop->so_time = get_seconds();
1852}
1853
Linus Torvalds1da177e2005-04-16 15:20:36 -07001854static int
J. Bruce Fields599e0a22007-07-26 17:04:54 -04001855same_owner_str(struct nfs4_stateowner *sop, struct xdr_netobj *owner,
1856 clientid_t *clid)
1857{
1858 return (sop->so_owner.len == owner->len) &&
1859 0 == memcmp(sop->so_owner.data, owner->data, owner->len) &&
1860 (sop->so_client->cl_clientid.cl_id == clid->cl_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001861}
1862
1863static struct nfs4_stateowner *
1864find_openstateowner_str(unsigned int hashval, struct nfsd4_open *open)
1865{
1866 struct nfs4_stateowner *so = NULL;
1867
1868 list_for_each_entry(so, &ownerstr_hashtbl[hashval], so_strhash) {
J. Bruce Fields599e0a22007-07-26 17:04:54 -04001869 if (same_owner_str(so, &open->op_owner, &open->op_clientid))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001870 return so;
1871 }
1872 return NULL;
1873}
1874
1875/* search file_hashtbl[] for file */
1876static struct nfs4_file *
1877find_file(struct inode *ino)
1878{
1879 unsigned int hashval = file_hashval(ino);
1880 struct nfs4_file *fp;
1881
J. Bruce Fields8b671b82009-02-22 14:51:34 -08001882 spin_lock(&recall_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001883 list_for_each_entry(fp, &file_hashtbl[hashval], fi_hash) {
NeilBrown13cd2182005-06-23 22:03:10 -07001884 if (fp->fi_inode == ino) {
1885 get_nfs4_file(fp);
J. Bruce Fields8b671b82009-02-22 14:51:34 -08001886 spin_unlock(&recall_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001887 return fp;
NeilBrown13cd2182005-06-23 22:03:10 -07001888 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001889 }
J. Bruce Fields8b671b82009-02-22 14:51:34 -08001890 spin_unlock(&recall_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001891 return NULL;
1892}
1893
Andy Adamsond87a8ad2009-04-03 08:28:53 +03001894static inline int access_valid(u32 x, u32 minorversion)
J. Bruce Fieldsba5a6a12006-06-30 01:56:16 -07001895{
Andy Adamsond87a8ad2009-04-03 08:28:53 +03001896 if ((x & NFS4_SHARE_ACCESS_MASK) < NFS4_SHARE_ACCESS_READ)
J. Bruce Fields8838dc42008-01-14 13:12:19 -05001897 return 0;
Andy Adamsond87a8ad2009-04-03 08:28:53 +03001898 if ((x & NFS4_SHARE_ACCESS_MASK) > NFS4_SHARE_ACCESS_BOTH)
1899 return 0;
1900 x &= ~NFS4_SHARE_ACCESS_MASK;
1901 if (minorversion && x) {
1902 if ((x & NFS4_SHARE_WANT_MASK) > NFS4_SHARE_WANT_CANCEL)
1903 return 0;
1904 if ((x & NFS4_SHARE_WHEN_MASK) > NFS4_SHARE_PUSH_DELEG_WHEN_UNCONTENDED)
1905 return 0;
1906 x &= ~(NFS4_SHARE_WANT_MASK | NFS4_SHARE_WHEN_MASK);
1907 }
1908 if (x)
J. Bruce Fields8838dc42008-01-14 13:12:19 -05001909 return 0;
1910 return 1;
J. Bruce Fieldsba5a6a12006-06-30 01:56:16 -07001911}
1912
J. Bruce Fields8838dc42008-01-14 13:12:19 -05001913static inline int deny_valid(u32 x)
J. Bruce Fieldsba5a6a12006-06-30 01:56:16 -07001914{
J. Bruce Fields8838dc42008-01-14 13:12:19 -05001915 /* Note: unlike access bits, deny bits may be zero. */
1916 return x <= NFS4_SHARE_DENY_BOTH;
J. Bruce Fieldsba5a6a12006-06-30 01:56:16 -07001917}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001918
J. Bruce Fields4f83aa32008-07-07 15:02:02 -04001919/*
1920 * We store the NONE, READ, WRITE, and BOTH bits separately in the
1921 * st_{access,deny}_bmap field of the stateid, in order to track not
1922 * only what share bits are currently in force, but also what
1923 * combinations of share bits previous opens have used. This allows us
1924 * to enforce the recommendation of rfc 3530 14.2.19 that the server
1925 * return an error if the client attempt to downgrade to a combination
1926 * of share bits not explicable by closing some of its previous opens.
1927 *
1928 * XXX: This enforcement is actually incomplete, since we don't keep
1929 * track of access/deny bit combinations; so, e.g., we allow:
1930 *
1931 * OPEN allow read, deny write
1932 * OPEN allow both, deny none
1933 * DOWNGRADE allow read, deny none
1934 *
1935 * which we should reject.
1936 */
NeilBrownfd39ca92005-06-23 22:04:03 -07001937static void
Linus Torvalds1da177e2005-04-16 15:20:36 -07001938set_access(unsigned int *access, unsigned long bmap) {
1939 int i;
1940
1941 *access = 0;
1942 for (i = 1; i < 4; i++) {
1943 if (test_bit(i, &bmap))
1944 *access |= i;
1945 }
1946}
1947
NeilBrownfd39ca92005-06-23 22:04:03 -07001948static void
Linus Torvalds1da177e2005-04-16 15:20:36 -07001949set_deny(unsigned int *deny, unsigned long bmap) {
1950 int i;
1951
1952 *deny = 0;
1953 for (i = 0; i < 4; i++) {
1954 if (test_bit(i, &bmap))
1955 *deny |= i ;
1956 }
1957}
1958
1959static int
1960test_share(struct nfs4_stateid *stp, struct nfsd4_open *open) {
1961 unsigned int access, deny;
1962
1963 set_access(&access, stp->st_access_bmap);
1964 set_deny(&deny, stp->st_deny_bmap);
1965 if ((access & open->op_share_deny) || (deny & open->op_share_access))
1966 return 0;
1967 return 1;
1968}
1969
1970/*
1971 * Called to check deny when READ with all zero stateid or
1972 * WRITE with all zero or all one stateid
1973 */
Al Virob37ad282006-10-19 23:28:59 -07001974static __be32
Linus Torvalds1da177e2005-04-16 15:20:36 -07001975nfs4_share_conflict(struct svc_fh *current_fh, unsigned int deny_type)
1976{
1977 struct inode *ino = current_fh->fh_dentry->d_inode;
1978 struct nfs4_file *fp;
1979 struct nfs4_stateid *stp;
Al Virob37ad282006-10-19 23:28:59 -07001980 __be32 ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001981
1982 dprintk("NFSD: nfs4_share_conflict\n");
1983
1984 fp = find_file(ino);
NeilBrown13cd2182005-06-23 22:03:10 -07001985 if (!fp)
1986 return nfs_ok;
NeilBrownb7009492005-07-07 17:59:23 -07001987 ret = nfserr_locked;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001988 /* Search for conflicting share reservations */
NeilBrown13cd2182005-06-23 22:03:10 -07001989 list_for_each_entry(stp, &fp->fi_stateids, st_perfile) {
1990 if (test_bit(deny_type, &stp->st_deny_bmap) ||
1991 test_bit(NFS4_SHARE_DENY_BOTH, &stp->st_deny_bmap))
1992 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001993 }
NeilBrown13cd2182005-06-23 22:03:10 -07001994 ret = nfs_ok;
1995out:
1996 put_nfs4_file(fp);
1997 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001998}
1999
2000static inline void
2001nfs4_file_downgrade(struct file *filp, unsigned int share_access)
2002{
2003 if (share_access & NFS4_SHARE_ACCESS_WRITE) {
Dave Hansenaceaf782008-02-15 14:37:31 -08002004 drop_file_write_access(filp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002005 filp->f_mode = (filp->f_mode | FMODE_READ) & ~FMODE_WRITE;
2006 }
2007}
2008
2009/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002010 * Spawn a thread to perform a recall on the delegation represented
2011 * by the lease (file_lock)
2012 *
2013 * Called from break_lease() with lock_kernel() held.
2014 * Note: we assume break_lease will only call this *once* for any given
2015 * lease.
2016 */
2017static
2018void nfsd_break_deleg_cb(struct file_lock *fl)
2019{
J. Bruce Fields63e48632009-05-01 22:36:55 -04002020 struct nfs4_delegation *dp = (struct nfs4_delegation *)fl->fl_owner;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002021
2022 dprintk("NFSD nfsd_break_deleg_cb: dp %p fl %p\n",dp,fl);
2023 if (!dp)
2024 return;
2025
2026 /* We're assuming the state code never drops its reference
2027 * without first removing the lease. Since we're in this lease
2028 * callback (and since the lease code is serialized by the kernel
2029 * lock) we know the server hasn't removed the lease yet, we know
2030 * it's safe to take a reference: */
2031 atomic_inc(&dp->dl_count);
J. Bruce Fieldscfdcad42007-09-12 20:35:15 -04002032 atomic_inc(&dp->dl_client->cl_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002033
2034 spin_lock(&recall_lock);
2035 list_add_tail(&dp->dl_recall_lru, &del_recall_lru);
2036 spin_unlock(&recall_lock);
2037
2038 /* only place dl_time is set. protected by lock_kernel*/
2039 dp->dl_time = get_seconds();
2040
J. Bruce Fields0272e1f2007-09-12 18:56:12 -04002041 /*
2042 * We don't want the locks code to timeout the lease for us;
2043 * we'll remove it ourself if the delegation isn't returned
2044 * in time.
2045 */
2046 fl->fl_break_time = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002047
J. Bruce Fields63e48632009-05-01 22:36:55 -04002048 dp->dl_file->fi_had_conflict = true;
2049 nfsd4_cb_recall(dp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002050}
2051
2052/*
2053 * The file_lock is being reapd.
2054 *
2055 * Called by locks_free_lock() with lock_kernel() held.
2056 */
2057static
2058void nfsd_release_deleg_cb(struct file_lock *fl)
2059{
2060 struct nfs4_delegation *dp = (struct nfs4_delegation *)fl->fl_owner;
2061
2062 dprintk("NFSD nfsd_release_deleg_cb: fl %p dp %p dl_count %d\n", fl,dp, atomic_read(&dp->dl_count));
2063
2064 if (!(fl->fl_flags & FL_LEASE) || !dp)
2065 return;
2066 dp->dl_flock = NULL;
2067}
2068
2069/*
2070 * Set the delegation file_lock back pointer.
2071 *
J. Bruce Fieldsa9933ce2007-06-07 17:09:49 -04002072 * Called from setlease() with lock_kernel() held.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002073 */
2074static
2075void nfsd_copy_lock_deleg_cb(struct file_lock *new, struct file_lock *fl)
2076{
2077 struct nfs4_delegation *dp = (struct nfs4_delegation *)new->fl_owner;
2078
2079 dprintk("NFSD: nfsd_copy_lock_deleg_cb: new fl %p dp %p\n", new, dp);
2080 if (!dp)
2081 return;
2082 dp->dl_flock = new;
2083}
2084
2085/*
J. Bruce Fieldsa9933ce2007-06-07 17:09:49 -04002086 * Called from setlease() with lock_kernel() held
Linus Torvalds1da177e2005-04-16 15:20:36 -07002087 */
2088static
2089int nfsd_same_client_deleg_cb(struct file_lock *onlist, struct file_lock *try)
2090{
2091 struct nfs4_delegation *onlistd =
2092 (struct nfs4_delegation *)onlist->fl_owner;
2093 struct nfs4_delegation *tryd =
2094 (struct nfs4_delegation *)try->fl_owner;
2095
2096 if (onlist->fl_lmops != try->fl_lmops)
2097 return 0;
2098
2099 return onlistd->dl_client == tryd->dl_client;
2100}
2101
2102
2103static
2104int nfsd_change_deleg_cb(struct file_lock **onlist, int arg)
2105{
2106 if (arg & F_UNLCK)
2107 return lease_modify(onlist, arg);
2108 else
2109 return -EAGAIN;
2110}
2111
Alexey Dobriyan7b021962009-09-21 17:01:12 -07002112static const struct lock_manager_operations nfsd_lease_mng_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002113 .fl_break = nfsd_break_deleg_cb,
2114 .fl_release_private = nfsd_release_deleg_cb,
2115 .fl_copy_lock = nfsd_copy_lock_deleg_cb,
2116 .fl_mylease = nfsd_same_client_deleg_cb,
2117 .fl_change = nfsd_change_deleg_cb,
2118};
2119
2120
Al Virob37ad282006-10-19 23:28:59 -07002121__be32
Andy Adamson66689582009-04-03 08:28:45 +03002122nfsd4_process_open1(struct nfsd4_compound_state *cstate,
2123 struct nfsd4_open *open)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002124{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002125 clientid_t *clientid = &open->op_clientid;
2126 struct nfs4_client *clp = NULL;
2127 unsigned int strhashval;
2128 struct nfs4_stateowner *sop = NULL;
2129
Linus Torvalds1da177e2005-04-16 15:20:36 -07002130 if (!check_name(open->op_owner))
J. Bruce Fields0f442aa2006-01-18 17:43:34 -08002131 return nfserr_inval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002132
2133 if (STALE_CLIENTID(&open->op_clientid))
2134 return nfserr_stale_clientid;
2135
2136 strhashval = ownerstr_hashval(clientid->cl_id, open->op_owner);
2137 sop = find_openstateowner_str(strhashval, open);
J. Bruce Fields0f442aa2006-01-18 17:43:34 -08002138 open->op_stateowner = sop;
2139 if (!sop) {
2140 /* Make sure the client's lease hasn't expired. */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002141 clp = find_confirmed_client(clientid);
2142 if (clp == NULL)
J. Bruce Fields0f442aa2006-01-18 17:43:34 -08002143 return nfserr_expired;
2144 goto renew;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002145 }
Andy Adamson66689582009-04-03 08:28:45 +03002146 /* When sessions are used, skip open sequenceid processing */
2147 if (nfsd4_has_session(cstate))
2148 goto renew;
J. Bruce Fields0f442aa2006-01-18 17:43:34 -08002149 if (!sop->so_confirmed) {
2150 /* Replace unconfirmed owners without checking for replay. */
2151 clp = sop->so_client;
J. Bruce Fieldsf044ff82009-01-11 15:24:04 -05002152 release_openowner(sop);
J. Bruce Fields0f442aa2006-01-18 17:43:34 -08002153 open->op_stateowner = NULL;
2154 goto renew;
2155 }
2156 if (open->op_seqid == sop->so_seqid - 1) {
2157 if (sop->so_replay.rp_buflen)
Al Viroa90b0612006-10-19 23:29:03 -07002158 return nfserr_replay_me;
J. Bruce Fields0f442aa2006-01-18 17:43:34 -08002159 /* The original OPEN failed so spectacularly
2160 * that we don't even have replay data saved!
2161 * Therefore, we have no choice but to continue
2162 * processing this OPEN; presumably, we'll
2163 * fail again for the same reason.
2164 */
2165 dprintk("nfsd4_process_open1: replay with no replay cache\n");
2166 goto renew;
2167 }
2168 if (open->op_seqid != sop->so_seqid)
2169 return nfserr_bad_seqid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002170renew:
J. Bruce Fields0f442aa2006-01-18 17:43:34 -08002171 if (open->op_stateowner == NULL) {
2172 sop = alloc_init_open_stateowner(strhashval, clp, open);
2173 if (sop == NULL)
2174 return nfserr_resource;
2175 open->op_stateowner = sop;
2176 }
2177 list_del_init(&sop->so_close_lru);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002178 renew_client(sop->so_client);
J. Bruce Fields0f442aa2006-01-18 17:43:34 -08002179 return nfs_ok;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002180}
2181
Al Virob37ad282006-10-19 23:28:59 -07002182static inline __be32
NeilBrown4a6e43e2005-06-23 22:02:50 -07002183nfs4_check_delegmode(struct nfs4_delegation *dp, int flags)
2184{
2185 if ((flags & WR_STATE) && (dp->dl_type == NFS4_OPEN_DELEGATE_READ))
2186 return nfserr_openmode;
2187 else
2188 return nfs_ok;
2189}
2190
NeilBrown52f4fb42005-06-23 22:02:49 -07002191static struct nfs4_delegation *
2192find_delegation_file(struct nfs4_file *fp, stateid_t *stid)
2193{
2194 struct nfs4_delegation *dp;
2195
NeilBrownea1da632005-06-23 22:04:17 -07002196 list_for_each_entry(dp, &fp->fi_delegations, dl_perfile) {
NeilBrown52f4fb42005-06-23 22:02:49 -07002197 if (dp->dl_stateid.si_stateownerid == stid->si_stateownerid)
2198 return dp;
2199 }
2200 return NULL;
2201}
2202
Al Virob37ad282006-10-19 23:28:59 -07002203static __be32
NeilBrown567d9822005-06-23 22:02:53 -07002204nfs4_check_deleg(struct nfs4_file *fp, struct nfsd4_open *open,
2205 struct nfs4_delegation **dp)
2206{
2207 int flags;
Al Virob37ad282006-10-19 23:28:59 -07002208 __be32 status = nfserr_bad_stateid;
NeilBrown567d9822005-06-23 22:02:53 -07002209
2210 *dp = find_delegation_file(fp, &open->op_delegate_stateid);
2211 if (*dp == NULL)
NeilBrownc44c5ee2005-06-23 22:02:54 -07002212 goto out;
NeilBrown567d9822005-06-23 22:02:53 -07002213 flags = open->op_share_access == NFS4_SHARE_ACCESS_READ ?
2214 RD_STATE : WR_STATE;
2215 status = nfs4_check_delegmode(*dp, flags);
2216 if (status)
2217 *dp = NULL;
NeilBrownc44c5ee2005-06-23 22:02:54 -07002218out:
2219 if (open->op_claim_type != NFS4_OPEN_CLAIM_DELEGATE_CUR)
2220 return nfs_ok;
2221 if (status)
2222 return status;
2223 open->op_stateowner->so_confirmed = 1;
2224 return nfs_ok;
NeilBrown567d9822005-06-23 22:02:53 -07002225}
2226
Al Virob37ad282006-10-19 23:28:59 -07002227static __be32
Linus Torvalds1da177e2005-04-16 15:20:36 -07002228nfs4_check_open(struct nfs4_file *fp, struct nfsd4_open *open, struct nfs4_stateid **stpp)
2229{
2230 struct nfs4_stateid *local;
Al Virob37ad282006-10-19 23:28:59 -07002231 __be32 status = nfserr_share_denied;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002232 struct nfs4_stateowner *sop = open->op_stateowner;
2233
NeilBrown8beefa22005-06-23 22:03:08 -07002234 list_for_each_entry(local, &fp->fi_stateids, st_perfile) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002235 /* ignore lock owners */
2236 if (local->st_stateowner->so_is_open_owner == 0)
2237 continue;
2238 /* remember if we have seen this open owner */
2239 if (local->st_stateowner == sop)
2240 *stpp = local;
2241 /* check for conflicting share reservations */
2242 if (!test_share(local, open))
2243 goto out;
2244 }
2245 status = 0;
2246out:
2247 return status;
2248}
2249
NeilBrown5ac049a2005-06-23 22:03:03 -07002250static inline struct nfs4_stateid *
2251nfs4_alloc_stateid(void)
2252{
2253 return kmem_cache_alloc(stateid_slab, GFP_KERNEL);
2254}
2255
Al Virob37ad282006-10-19 23:28:59 -07002256static __be32
Linus Torvalds1da177e2005-04-16 15:20:36 -07002257nfs4_new_open(struct svc_rqst *rqstp, struct nfs4_stateid **stpp,
NeilBrown567d9822005-06-23 22:02:53 -07002258 struct nfs4_delegation *dp,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002259 struct svc_fh *cur_fh, int flags)
2260{
2261 struct nfs4_stateid *stp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002262
NeilBrown5ac049a2005-06-23 22:03:03 -07002263 stp = nfs4_alloc_stateid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002264 if (stp == NULL)
2265 return nfserr_resource;
2266
NeilBrown567d9822005-06-23 22:02:53 -07002267 if (dp) {
2268 get_file(dp->dl_vfs_file);
2269 stp->st_vfs_file = dp->dl_vfs_file;
2270 } else {
Al Virob37ad282006-10-19 23:28:59 -07002271 __be32 status;
NeilBrown567d9822005-06-23 22:02:53 -07002272 status = nfsd_open(rqstp, cur_fh, S_IFREG, flags,
2273 &stp->st_vfs_file);
2274 if (status) {
2275 if (status == nfserr_dropit)
2276 status = nfserr_jukebox;
NeilBrown5ac049a2005-06-23 22:03:03 -07002277 kmem_cache_free(stateid_slab, stp);
NeilBrown567d9822005-06-23 22:02:53 -07002278 return status;
2279 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002280 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002281 *stpp = stp;
2282 return 0;
2283}
2284
Al Virob37ad282006-10-19 23:28:59 -07002285static inline __be32
Linus Torvalds1da177e2005-04-16 15:20:36 -07002286nfsd4_truncate(struct svc_rqst *rqstp, struct svc_fh *fh,
2287 struct nfsd4_open *open)
2288{
2289 struct iattr iattr = {
2290 .ia_valid = ATTR_SIZE,
2291 .ia_size = 0,
2292 };
2293 if (!open->op_truncate)
2294 return 0;
2295 if (!(open->op_share_access & NFS4_SHARE_ACCESS_WRITE))
Al Viro92465852006-01-18 17:43:46 -08002296 return nfserr_inval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002297 return nfsd_setattr(rqstp, fh, &iattr, 0, (time_t)0);
2298}
2299
Al Virob37ad282006-10-19 23:28:59 -07002300static __be32
Linus Torvalds1da177e2005-04-16 15:20:36 -07002301nfs4_upgrade_open(struct svc_rqst *rqstp, struct svc_fh *cur_fh, struct nfs4_stateid *stp, struct nfsd4_open *open)
2302{
2303 struct file *filp = stp->st_vfs_file;
Josef "Jeff" Sipek7eaa36e2006-12-08 02:36:41 -08002304 struct inode *inode = filp->f_path.dentry->d_inode;
J. Bruce Fields6c26d082006-01-18 17:43:38 -08002305 unsigned int share_access, new_writer;
Al Virob37ad282006-10-19 23:28:59 -07002306 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002307
2308 set_access(&share_access, stp->st_access_bmap);
J. Bruce Fields6c26d082006-01-18 17:43:38 -08002309 new_writer = (~share_access) & open->op_share_access
2310 & NFS4_SHARE_ACCESS_WRITE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002311
J. Bruce Fields6c26d082006-01-18 17:43:38 -08002312 if (new_writer) {
Al Virob37ad282006-10-19 23:28:59 -07002313 int err = get_write_access(inode);
2314 if (err)
2315 return nfserrno(err);
Benny Halevye518f052008-07-04 15:38:41 +03002316 err = mnt_want_write(cur_fh->fh_export->ex_path.mnt);
2317 if (err)
2318 return nfserrno(err);
2319 file_take_write(filp);
J. Bruce Fields6c26d082006-01-18 17:43:38 -08002320 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002321 status = nfsd4_truncate(rqstp, cur_fh, open);
2322 if (status) {
J. Bruce Fields6c26d082006-01-18 17:43:38 -08002323 if (new_writer)
2324 put_write_access(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002325 return status;
2326 }
2327 /* remember the open */
J. Bruce Fields6c26d082006-01-18 17:43:38 -08002328 filp->f_mode |= open->op_share_access;
J. Bruce Fieldsb55e0ba2008-04-28 18:22:50 -04002329 __set_bit(open->op_share_access, &stp->st_access_bmap);
2330 __set_bit(open->op_share_deny, &stp->st_deny_bmap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002331
2332 return nfs_ok;
2333}
2334
2335
Linus Torvalds1da177e2005-04-16 15:20:36 -07002336static void
NeilBrown37515172005-07-07 17:59:16 -07002337nfs4_set_claim_prev(struct nfsd4_open *open)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002338{
NeilBrown37515172005-07-07 17:59:16 -07002339 open->op_stateowner->so_confirmed = 1;
2340 open->op_stateowner->so_client->cl_firststate = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002341}
2342
2343/*
2344 * Attempt to hand out a delegation.
2345 */
2346static void
2347nfs4_open_delegation(struct svc_fh *fh, struct nfsd4_open *open, struct nfs4_stateid *stp)
2348{
2349 struct nfs4_delegation *dp;
2350 struct nfs4_stateowner *sop = stp->st_stateowner;
J. Bruce Fieldsc237dc02009-04-29 19:09:19 -04002351 struct nfs4_cb_conn *cb = &sop->so_client->cl_cb_conn;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002352 struct file_lock fl, *flp = &fl;
2353 int status, flag = 0;
2354
2355 flag = NFS4_OPEN_DELEGATE_NONE;
NeilBrown7b190fe2005-06-23 22:03:23 -07002356 open->op_recall = 0;
2357 switch (open->op_claim_type) {
2358 case NFS4_OPEN_CLAIM_PREVIOUS:
2359 if (!atomic_read(&cb->cb_set))
2360 open->op_recall = 1;
2361 flag = open->op_delegate_type;
2362 if (flag == NFS4_OPEN_DELEGATE_NONE)
2363 goto out;
2364 break;
2365 case NFS4_OPEN_CLAIM_NULL:
2366 /* Let's not give out any delegations till everyone's
2367 * had the chance to reclaim theirs.... */
J. Bruce Fieldsaf558e32007-09-06 12:34:25 -04002368 if (locks_in_grace())
NeilBrown7b190fe2005-06-23 22:03:23 -07002369 goto out;
2370 if (!atomic_read(&cb->cb_set) || !sop->so_confirmed)
2371 goto out;
2372 if (open->op_share_access & NFS4_SHARE_ACCESS_WRITE)
2373 flag = NFS4_OPEN_DELEGATE_WRITE;
2374 else
2375 flag = NFS4_OPEN_DELEGATE_READ;
2376 break;
2377 default:
2378 goto out;
2379 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002380
2381 dp = alloc_init_deleg(sop->so_client, stp, fh, flag);
2382 if (dp == NULL) {
2383 flag = NFS4_OPEN_DELEGATE_NONE;
2384 goto out;
2385 }
2386 locks_init_lock(&fl);
2387 fl.fl_lmops = &nfsd_lease_mng_ops;
2388 fl.fl_flags = FL_LEASE;
Felix Blyakher9167f502008-02-26 10:54:36 -08002389 fl.fl_type = flag == NFS4_OPEN_DELEGATE_READ? F_RDLCK: F_WRLCK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002390 fl.fl_end = OFFSET_MAX;
2391 fl.fl_owner = (fl_owner_t)dp;
2392 fl.fl_file = stp->st_vfs_file;
2393 fl.fl_pid = current->tgid;
2394
J. Bruce Fieldsa9933ce2007-06-07 17:09:49 -04002395 /* vfs_setlease checks to see if delegation should be handed out.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002396 * the lock_manager callbacks fl_mylease and fl_change are used
2397 */
Felix Blyakher9167f502008-02-26 10:54:36 -08002398 if ((status = vfs_setlease(stp->st_vfs_file, fl.fl_type, &flp))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002399 dprintk("NFSD: setlease failed [%d], no delegation\n", status);
NeilBrownc9071322005-04-16 15:26:38 -07002400 unhash_delegation(dp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002401 flag = NFS4_OPEN_DELEGATE_NONE;
2402 goto out;
2403 }
2404
2405 memcpy(&open->op_delegate_stateid, &dp->dl_stateid, sizeof(dp->dl_stateid));
2406
2407 dprintk("NFSD: delegation stateid=(%08x/%08x/%08x/%08x)\n\n",
2408 dp->dl_stateid.si_boot,
2409 dp->dl_stateid.si_stateownerid,
2410 dp->dl_stateid.si_fileid,
2411 dp->dl_stateid.si_generation);
2412out:
NeilBrown7b190fe2005-06-23 22:03:23 -07002413 if (open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS
2414 && flag == NFS4_OPEN_DELEGATE_NONE
2415 && open->op_delegate_type != NFS4_OPEN_DELEGATE_NONE)
J. Bruce Fields2fdada02007-07-27 16:10:37 -04002416 dprintk("NFSD: WARNING: refusing delegation reclaim\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002417 open->op_delegate_type = flag;
2418}
2419
2420/*
2421 * called with nfs4_lock_state() held.
2422 */
Al Virob37ad282006-10-19 23:28:59 -07002423__be32
Linus Torvalds1da177e2005-04-16 15:20:36 -07002424nfsd4_process_open2(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_open *open)
2425{
Andy Adamson66689582009-04-03 08:28:45 +03002426 struct nfsd4_compoundres *resp = rqstp->rq_resp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002427 struct nfs4_file *fp = NULL;
2428 struct inode *ino = current_fh->fh_dentry->d_inode;
2429 struct nfs4_stateid *stp = NULL;
NeilBrown567d9822005-06-23 22:02:53 -07002430 struct nfs4_delegation *dp = NULL;
Al Virob37ad282006-10-19 23:28:59 -07002431 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002432
2433 status = nfserr_inval;
Andy Adamsond87a8ad2009-04-03 08:28:53 +03002434 if (!access_valid(open->op_share_access, resp->cstate.minorversion)
J. Bruce Fieldsba5a6a12006-06-30 01:56:16 -07002435 || !deny_valid(open->op_share_deny))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002436 goto out;
2437 /*
2438 * Lookup file; if found, lookup stateid and check open request,
2439 * and check for delegations in the process of being recalled.
2440 * If not found, create the nfs4_file struct
2441 */
2442 fp = find_file(ino);
2443 if (fp) {
2444 if ((status = nfs4_check_open(fp, open, &stp)))
2445 goto out;
NeilBrownc44c5ee2005-06-23 22:02:54 -07002446 status = nfs4_check_deleg(fp, open, &dp);
2447 if (status)
2448 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002449 } else {
NeilBrownc44c5ee2005-06-23 22:02:54 -07002450 status = nfserr_bad_stateid;
2451 if (open->op_claim_type == NFS4_OPEN_CLAIM_DELEGATE_CUR)
2452 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002453 status = nfserr_resource;
2454 fp = alloc_init_file(ino);
2455 if (fp == NULL)
2456 goto out;
2457 }
2458
2459 /*
2460 * OPEN the file, or upgrade an existing OPEN.
2461 * If truncate fails, the OPEN fails.
2462 */
2463 if (stp) {
2464 /* Stateid was found, this is an OPEN upgrade */
2465 status = nfs4_upgrade_open(rqstp, current_fh, stp, open);
2466 if (status)
2467 goto out;
NeilBrown444c2c02005-07-07 17:59:22 -07002468 update_stateid(&stp->st_stateid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002469 } else {
2470 /* Stateid was not found, this is a new OPEN */
2471 int flags = 0;
J. Bruce Fields9ecb6a02006-06-30 01:56:17 -07002472 if (open->op_share_access & NFS4_SHARE_ACCESS_READ)
Miklos Szeredi8837abc2008-06-16 13:20:29 +02002473 flags |= NFSD_MAY_READ;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002474 if (open->op_share_access & NFS4_SHARE_ACCESS_WRITE)
Miklos Szeredi8837abc2008-06-16 13:20:29 +02002475 flags |= NFSD_MAY_WRITE;
NeilBrown567d9822005-06-23 22:02:53 -07002476 status = nfs4_new_open(rqstp, &stp, dp, current_fh, flags);
2477 if (status)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002478 goto out;
2479 init_stateid(stp, fp, open);
2480 status = nfsd4_truncate(rqstp, current_fh, open);
2481 if (status) {
J. Bruce Fields22839632009-01-11 14:27:17 -05002482 release_open_stateid(stp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002483 goto out;
2484 }
Andy Adamson66689582009-04-03 08:28:45 +03002485 if (nfsd4_has_session(&resp->cstate))
2486 update_stateid(&stp->st_stateid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002487 }
2488 memcpy(&open->op_stateid, &stp->st_stateid, sizeof(stateid_t));
2489
Andy Adamson66689582009-04-03 08:28:45 +03002490 if (nfsd4_has_session(&resp->cstate))
2491 open->op_stateowner->so_confirmed = 1;
2492
Linus Torvalds1da177e2005-04-16 15:20:36 -07002493 /*
2494 * Attempt to hand out a delegation. No error return, because the
2495 * OPEN succeeds even if we fail.
2496 */
2497 nfs4_open_delegation(current_fh, open, stp);
2498
2499 status = nfs_ok;
2500
2501 dprintk("nfs4_process_open2: stateid=(%08x/%08x/%08x/%08x)\n",
2502 stp->st_stateid.si_boot, stp->st_stateid.si_stateownerid,
2503 stp->st_stateid.si_fileid, stp->st_stateid.si_generation);
2504out:
NeilBrown13cd2182005-06-23 22:03:10 -07002505 if (fp)
2506 put_nfs4_file(fp);
NeilBrown37515172005-07-07 17:59:16 -07002507 if (status == 0 && open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS)
2508 nfs4_set_claim_prev(open);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002509 /*
2510 * To finish the open response, we just need to set the rflags.
2511 */
2512 open->op_rflags = NFS4_OPEN_RESULT_LOCKTYPE_POSIX;
Andy Adamson66689582009-04-03 08:28:45 +03002513 if (!open->op_stateowner->so_confirmed &&
2514 !nfsd4_has_session(&resp->cstate))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002515 open->op_rflags |= NFS4_OPEN_RESULT_CONFIRM;
2516
2517 return status;
2518}
2519
Al Virob37ad282006-10-19 23:28:59 -07002520__be32
J.Bruce Fieldsb5914802006-12-13 00:35:38 -08002521nfsd4_renew(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
2522 clientid_t *clid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002523{
2524 struct nfs4_client *clp;
Al Virob37ad282006-10-19 23:28:59 -07002525 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002526
2527 nfs4_lock_state();
2528 dprintk("process_renew(%08x/%08x): starting\n",
2529 clid->cl_boot, clid->cl_id);
2530 status = nfserr_stale_clientid;
2531 if (STALE_CLIENTID(clid))
2532 goto out;
2533 clp = find_confirmed_client(clid);
2534 status = nfserr_expired;
2535 if (clp == NULL) {
2536 /* We assume the client took too long to RENEW. */
2537 dprintk("nfsd4_renew: clientid not found!\n");
2538 goto out;
2539 }
2540 renew_client(clp);
2541 status = nfserr_cb_path_down;
NeilBrownea1da632005-06-23 22:04:17 -07002542 if (!list_empty(&clp->cl_delegations)
J. Bruce Fieldsc237dc02009-04-29 19:09:19 -04002543 && !atomic_read(&clp->cl_cb_conn.cb_set))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002544 goto out;
2545 status = nfs_ok;
2546out:
2547 nfs4_unlock_state();
2548 return status;
2549}
2550
J. Bruce Fieldsaf558e32007-09-06 12:34:25 -04002551struct lock_manager nfsd4_manager = {
2552};
2553
NeilBrowna76b4312005-06-23 22:04:01 -07002554static void
J. Bruce Fieldsaf558e32007-09-06 12:34:25 -04002555nfsd4_end_grace(void)
NeilBrowna76b4312005-06-23 22:04:01 -07002556{
2557 dprintk("NFSD: end of grace period\n");
NeilBrownc7b9a452005-06-23 22:04:30 -07002558 nfsd4_recdir_purge_old();
J. Bruce Fieldsaf558e32007-09-06 12:34:25 -04002559 locks_end_grace(&nfsd4_manager);
NeilBrowna76b4312005-06-23 22:04:01 -07002560}
2561
NeilBrownfd39ca92005-06-23 22:04:03 -07002562static time_t
Linus Torvalds1da177e2005-04-16 15:20:36 -07002563nfs4_laundromat(void)
2564{
2565 struct nfs4_client *clp;
2566 struct nfs4_stateowner *sop;
2567 struct nfs4_delegation *dp;
2568 struct list_head *pos, *next, reaplist;
2569 time_t cutoff = get_seconds() - NFSD_LEASE_TIME;
2570 time_t t, clientid_val = NFSD_LEASE_TIME;
2571 time_t u, test_val = NFSD_LEASE_TIME;
2572
2573 nfs4_lock_state();
2574
2575 dprintk("NFSD: laundromat service - starting\n");
J. Bruce Fieldsaf558e32007-09-06 12:34:25 -04002576 if (locks_in_grace())
2577 nfsd4_end_grace();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002578 list_for_each_safe(pos, next, &client_lru) {
2579 clp = list_entry(pos, struct nfs4_client, cl_lru);
2580 if (time_after((unsigned long)clp->cl_time, (unsigned long)cutoff)) {
2581 t = clp->cl_time - cutoff;
2582 if (clientid_val > t)
2583 clientid_val = t;
2584 break;
2585 }
2586 dprintk("NFSD: purging unused client (clientid %08x)\n",
2587 clp->cl_clientid.cl_id);
NeilBrownc7b9a452005-06-23 22:04:30 -07002588 nfsd4_remove_clid_dir(clp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002589 expire_client(clp);
2590 }
2591 INIT_LIST_HEAD(&reaplist);
2592 spin_lock(&recall_lock);
2593 list_for_each_safe(pos, next, &del_recall_lru) {
2594 dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
2595 if (time_after((unsigned long)dp->dl_time, (unsigned long)cutoff)) {
2596 u = dp->dl_time - cutoff;
2597 if (test_val > u)
2598 test_val = u;
2599 break;
2600 }
2601 dprintk("NFSD: purging unused delegation dp %p, fp %p\n",
2602 dp, dp->dl_flock);
2603 list_move(&dp->dl_recall_lru, &reaplist);
2604 }
2605 spin_unlock(&recall_lock);
2606 list_for_each_safe(pos, next, &reaplist) {
2607 dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
2608 list_del_init(&dp->dl_recall_lru);
2609 unhash_delegation(dp);
2610 }
2611 test_val = NFSD_LEASE_TIME;
2612 list_for_each_safe(pos, next, &close_lru) {
2613 sop = list_entry(pos, struct nfs4_stateowner, so_close_lru);
2614 if (time_after((unsigned long)sop->so_time, (unsigned long)cutoff)) {
2615 u = sop->so_time - cutoff;
2616 if (test_val > u)
2617 test_val = u;
2618 break;
2619 }
2620 dprintk("NFSD: purging unused open stateowner (so_id %d)\n",
2621 sop->so_id);
J. Bruce Fieldsf044ff82009-01-11 15:24:04 -05002622 release_openowner(sop);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002623 }
2624 if (clientid_val < NFSD_LAUNDROMAT_MINTIMEOUT)
2625 clientid_val = NFSD_LAUNDROMAT_MINTIMEOUT;
2626 nfs4_unlock_state();
2627 return clientid_val;
2628}
2629
Harvey Harrisona254b242008-02-20 12:49:00 -08002630static struct workqueue_struct *laundry_wq;
2631static void laundromat_main(struct work_struct *);
2632static DECLARE_DELAYED_WORK(laundromat_work, laundromat_main);
2633
2634static void
David Howellsc4028952006-11-22 14:57:56 +00002635laundromat_main(struct work_struct *not_used)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002636{
2637 time_t t;
2638
2639 t = nfs4_laundromat();
2640 dprintk("NFSD: laundromat_main - sleeping for %ld seconds\n", t);
NeilBrown58da2822005-06-23 22:03:19 -07002641 queue_delayed_work(laundry_wq, &laundromat_work, t*HZ);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002642}
2643
NeilBrownfd39ca92005-06-23 22:04:03 -07002644static struct nfs4_stateowner *
NeilBrownf8816512005-07-07 17:59:25 -07002645search_close_lru(u32 st_id, int flags)
2646{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002647 struct nfs4_stateowner *local = NULL;
2648
Linus Torvalds1da177e2005-04-16 15:20:36 -07002649 if (flags & CLOSE_STATE) {
2650 list_for_each_entry(local, &close_lru, so_close_lru) {
2651 if (local->so_id == st_id)
2652 return local;
2653 }
2654 }
2655 return NULL;
2656}
2657
2658static inline int
2659nfs4_check_fh(struct svc_fh *fhp, struct nfs4_stateid *stp)
2660{
Josef "Jeff" Sipek7eaa36e2006-12-08 02:36:41 -08002661 return fhp->fh_dentry->d_inode != stp->st_vfs_file->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002662}
2663
2664static int
2665STALE_STATEID(stateid_t *stateid)
2666{
Bian Naimeng78155ed2009-04-22 18:25:37 +08002667 if (time_after((unsigned long)boot_time,
2668 (unsigned long)stateid->si_boot)) {
2669 dprintk("NFSD: stale stateid (%08x/%08x/%08x/%08x)!\n",
2670 stateid->si_boot, stateid->si_stateownerid,
2671 stateid->si_fileid, stateid->si_generation);
2672 return 1;
2673 }
2674 return 0;
2675}
2676
2677static int
2678EXPIRED_STATEID(stateid_t *stateid)
2679{
2680 if (time_before((unsigned long)boot_time,
2681 ((unsigned long)stateid->si_boot)) &&
J. Bruce Fieldsb8fd47a2009-04-29 11:36:17 -04002682 time_before((unsigned long)(stateid->si_boot + lease_time), get_seconds())) {
Bian Naimeng78155ed2009-04-22 18:25:37 +08002683 dprintk("NFSD: expired stateid (%08x/%08x/%08x/%08x)!\n",
2684 stateid->si_boot, stateid->si_stateownerid,
2685 stateid->si_fileid, stateid->si_generation);
2686 return 1;
2687 }
2688 return 0;
2689}
2690
2691static __be32
2692stateid_error_map(stateid_t *stateid)
2693{
2694 if (STALE_STATEID(stateid))
2695 return nfserr_stale_stateid;
2696 if (EXPIRED_STATEID(stateid))
2697 return nfserr_expired;
2698
2699 dprintk("NFSD: bad stateid (%08x/%08x/%08x/%08x)!\n",
2700 stateid->si_boot, stateid->si_stateownerid,
2701 stateid->si_fileid, stateid->si_generation);
2702 return nfserr_bad_stateid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002703}
2704
2705static inline int
2706access_permit_read(unsigned long access_bmap)
2707{
2708 return test_bit(NFS4_SHARE_ACCESS_READ, &access_bmap) ||
2709 test_bit(NFS4_SHARE_ACCESS_BOTH, &access_bmap) ||
2710 test_bit(NFS4_SHARE_ACCESS_WRITE, &access_bmap);
2711}
2712
2713static inline int
2714access_permit_write(unsigned long access_bmap)
2715{
2716 return test_bit(NFS4_SHARE_ACCESS_WRITE, &access_bmap) ||
2717 test_bit(NFS4_SHARE_ACCESS_BOTH, &access_bmap);
2718}
2719
2720static
Al Virob37ad282006-10-19 23:28:59 -07002721__be32 nfs4_check_openmode(struct nfs4_stateid *stp, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002722{
Al Virob37ad282006-10-19 23:28:59 -07002723 __be32 status = nfserr_openmode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002724
2725 if ((flags & WR_STATE) && (!access_permit_write(stp->st_access_bmap)))
2726 goto out;
2727 if ((flags & RD_STATE) && (!access_permit_read(stp->st_access_bmap)))
2728 goto out;
2729 status = nfs_ok;
2730out:
2731 return status;
2732}
2733
Al Virob37ad282006-10-19 23:28:59 -07002734static inline __be32
Linus Torvalds1da177e2005-04-16 15:20:36 -07002735check_special_stateids(svc_fh *current_fh, stateid_t *stateid, int flags)
2736{
J. Bruce Fields203a8c82009-02-21 13:29:14 -08002737 if (ONE_STATEID(stateid) && (flags & RD_STATE))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002738 return nfs_ok;
J. Bruce Fieldsaf558e32007-09-06 12:34:25 -04002739 else if (locks_in_grace()) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002740 /* Answer in remaining cases depends on existance of
2741 * conflicting state; so we must wait out the grace period. */
2742 return nfserr_grace;
2743 } else if (flags & WR_STATE)
2744 return nfs4_share_conflict(current_fh,
2745 NFS4_SHARE_DENY_WRITE);
2746 else /* (flags & RD_STATE) && ZERO_STATEID(stateid) */
2747 return nfs4_share_conflict(current_fh,
2748 NFS4_SHARE_DENY_READ);
2749}
2750
2751/*
2752 * Allow READ/WRITE during grace period on recovered state only for files
2753 * that are not able to provide mandatory locking.
2754 */
2755static inline int
J. Bruce Fields18f82732009-02-21 15:23:01 -08002756grace_disallows_io(struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002757{
J. Bruce Fields203a8c82009-02-21 13:29:14 -08002758 return locks_in_grace() && mandatory_lock(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002759}
2760
Andy Adamson66689582009-04-03 08:28:45 +03002761static int check_stateid_generation(stateid_t *in, stateid_t *ref, int flags)
J. Bruce Fields0836f582008-01-26 19:08:12 -05002762{
Andy Adamson66689582009-04-03 08:28:45 +03002763 /*
2764 * When sessions are used the stateid generation number is ignored
2765 * when it is zero.
2766 */
2767 if ((flags & HAS_SESSION) && in->si_generation == 0)
2768 goto out;
2769
J. Bruce Fields0836f582008-01-26 19:08:12 -05002770 /* If the client sends us a stateid from the future, it's buggy: */
2771 if (in->si_generation > ref->si_generation)
2772 return nfserr_bad_stateid;
2773 /*
2774 * The following, however, can happen. For example, if the
2775 * client sends an open and some IO at the same time, the open
2776 * may bump si_generation while the IO is still in flight.
2777 * Thanks to hard links and renames, the client never knows what
2778 * file an open will affect. So it could avoid that situation
2779 * only by serializing all opens and IO from the same open
2780 * owner. To recover from the old_stateid error, the client
2781 * will just have to retry the IO:
2782 */
2783 if (in->si_generation < ref->si_generation)
2784 return nfserr_old_stateid;
Andy Adamson66689582009-04-03 08:28:45 +03002785out:
J. Bruce Fields0836f582008-01-26 19:08:12 -05002786 return nfs_ok;
2787}
2788
J. Bruce Fields3e633072009-02-21 13:17:19 -08002789static int is_delegation_stateid(stateid_t *stateid)
2790{
2791 return stateid->si_fileid == 0;
2792}
2793
Linus Torvalds1da177e2005-04-16 15:20:36 -07002794/*
2795* Checks for stateid operations
2796*/
Al Virob37ad282006-10-19 23:28:59 -07002797__be32
Benny Halevydd453df2009-04-03 08:28:41 +03002798nfs4_preprocess_stateid_op(struct nfsd4_compound_state *cstate,
2799 stateid_t *stateid, int flags, struct file **filpp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002800{
2801 struct nfs4_stateid *stp = NULL;
2802 struct nfs4_delegation *dp = NULL;
Benny Halevydd453df2009-04-03 08:28:41 +03002803 struct svc_fh *current_fh = &cstate->current_fh;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002804 struct inode *ino = current_fh->fh_dentry->d_inode;
Al Virob37ad282006-10-19 23:28:59 -07002805 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002806
Linus Torvalds1da177e2005-04-16 15:20:36 -07002807 if (filpp)
2808 *filpp = NULL;
2809
J. Bruce Fields18f82732009-02-21 15:23:01 -08002810 if (grace_disallows_io(ino))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002811 return nfserr_grace;
2812
Andy Adamson66689582009-04-03 08:28:45 +03002813 if (nfsd4_has_session(cstate))
2814 flags |= HAS_SESSION;
2815
Linus Torvalds1da177e2005-04-16 15:20:36 -07002816 if (ZERO_STATEID(stateid) || ONE_STATEID(stateid))
2817 return check_special_stateids(current_fh, stateid, flags);
2818
Linus Torvalds1da177e2005-04-16 15:20:36 -07002819 status = nfserr_stale_stateid;
2820 if (STALE_STATEID(stateid))
2821 goto out;
2822
Linus Torvalds1da177e2005-04-16 15:20:36 -07002823 status = nfserr_bad_stateid;
J. Bruce Fields3e633072009-02-21 13:17:19 -08002824 if (is_delegation_stateid(stateid)) {
J. Bruce Fieldsa4455be2009-02-21 10:40:22 -08002825 dp = find_delegation_stateid(ino, stateid);
Bian Naimeng78155ed2009-04-22 18:25:37 +08002826 if (!dp) {
2827 status = stateid_error_map(stateid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002828 goto out;
Bian Naimeng78155ed2009-04-22 18:25:37 +08002829 }
Andy Adamson66689582009-04-03 08:28:45 +03002830 status = check_stateid_generation(stateid, &dp->dl_stateid,
2831 flags);
J. Bruce Fields0c2a4982009-02-21 11:11:50 -08002832 if (status)
2833 goto out;
J. Bruce Fieldsdc9bf702009-02-21 11:14:43 -08002834 status = nfs4_check_delegmode(dp, flags);
2835 if (status)
2836 goto out;
2837 renew_client(dp->dl_client);
J. Bruce Fieldsdc9bf702009-02-21 11:14:43 -08002838 if (filpp)
2839 *filpp = dp->dl_vfs_file;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002840 } else { /* open or lock stateid */
J. Bruce Fieldsa4455be2009-02-21 10:40:22 -08002841 stp = find_stateid(stateid, flags);
Bian Naimeng78155ed2009-04-22 18:25:37 +08002842 if (!stp) {
2843 status = stateid_error_map(stateid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002844 goto out;
Bian Naimeng78155ed2009-04-22 18:25:37 +08002845 }
J. Bruce Fields6150ef02009-02-21 13:36:16 -08002846 if (nfs4_check_fh(current_fh, stp))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002847 goto out;
2848 if (!stp->st_stateowner->so_confirmed)
2849 goto out;
Andy Adamson66689582009-04-03 08:28:45 +03002850 status = check_stateid_generation(stateid, &stp->st_stateid,
2851 flags);
J. Bruce Fields0c2a4982009-02-21 11:11:50 -08002852 if (status)
2853 goto out;
J. Bruce Fieldsa4455be2009-02-21 10:40:22 -08002854 status = nfs4_check_openmode(stp, flags);
2855 if (status)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002856 goto out;
2857 renew_client(stp->st_stateowner->so_client);
2858 if (filpp)
2859 *filpp = stp->st_vfs_file;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002860 }
2861 status = nfs_ok;
2862out:
2863 return status;
2864}
2865
NeilBrown4c4cd222005-07-07 17:59:27 -07002866static inline int
2867setlkflg (int type)
2868{
2869 return (type == NFS4_READW_LT || type == NFS4_READ_LT) ?
2870 RD_STATE : WR_STATE;
2871}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002872
2873/*
2874 * Checks for sequence id mutating operations.
2875 */
Al Virob37ad282006-10-19 23:28:59 -07002876static __be32
Benny Halevydd453df2009-04-03 08:28:41 +03002877nfs4_preprocess_seqid_op(struct nfsd4_compound_state *cstate, u32 seqid,
2878 stateid_t *stateid, int flags,
2879 struct nfs4_stateowner **sopp,
2880 struct nfs4_stateid **stpp, struct nfsd4_lock *lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002881{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002882 struct nfs4_stateid *stp;
2883 struct nfs4_stateowner *sop;
Benny Halevydd453df2009-04-03 08:28:41 +03002884 struct svc_fh *current_fh = &cstate->current_fh;
J. Bruce Fields0836f582008-01-26 19:08:12 -05002885 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002886
2887 dprintk("NFSD: preprocess_seqid_op: seqid=%d "
2888 "stateid = (%08x/%08x/%08x/%08x)\n", seqid,
2889 stateid->si_boot, stateid->si_stateownerid, stateid->si_fileid,
2890 stateid->si_generation);
NeilBrown3a4f98b2005-07-07 17:59:26 -07002891
Linus Torvalds1da177e2005-04-16 15:20:36 -07002892 *stpp = NULL;
2893 *sopp = NULL;
2894
Linus Torvalds1da177e2005-04-16 15:20:36 -07002895 if (ZERO_STATEID(stateid) || ONE_STATEID(stateid)) {
J. Bruce Fields2fdada02007-07-27 16:10:37 -04002896 dprintk("NFSD: preprocess_seqid_op: magic stateid!\n");
NeilBrown3a4f98b2005-07-07 17:59:26 -07002897 return nfserr_bad_stateid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002898 }
2899
Linus Torvalds1da177e2005-04-16 15:20:36 -07002900 if (STALE_STATEID(stateid))
NeilBrown3a4f98b2005-07-07 17:59:26 -07002901 return nfserr_stale_stateid;
Andy Adamson66689582009-04-03 08:28:45 +03002902
2903 if (nfsd4_has_session(cstate))
2904 flags |= HAS_SESSION;
2905
Linus Torvalds1da177e2005-04-16 15:20:36 -07002906 /*
2907 * We return BAD_STATEID if filehandle doesn't match stateid,
2908 * the confirmed flag is incorrecly set, or the generation
2909 * number is incorrect.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002910 */
NeilBrownf8816512005-07-07 17:59:25 -07002911 stp = find_stateid(stateid, flags);
2912 if (stp == NULL) {
2913 /*
2914 * Also, we should make sure this isn't just the result of
2915 * a replayed close:
2916 */
2917 sop = search_close_lru(stateid->si_stateownerid, flags);
2918 if (sop == NULL)
Bian Naimeng78155ed2009-04-22 18:25:37 +08002919 return stateid_error_map(stateid);
NeilBrownf8816512005-07-07 17:59:25 -07002920 *sopp = sop;
2921 goto check_replay;
2922 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002923
J. Bruce Fields39325bd2007-11-26 17:06:39 -05002924 *stpp = stp;
2925 *sopp = sop = stp->st_stateowner;
2926
NeilBrown4c4cd222005-07-07 17:59:27 -07002927 if (lock) {
NeilBrown4c4cd222005-07-07 17:59:27 -07002928 clientid_t *lockclid = &lock->v.new.clientid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002929 struct nfs4_client *clp = sop->so_client;
NeilBrown4c4cd222005-07-07 17:59:27 -07002930 int lkflg = 0;
Al Virob37ad282006-10-19 23:28:59 -07002931 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002932
NeilBrown4c4cd222005-07-07 17:59:27 -07002933 lkflg = setlkflg(lock->lk_type);
2934
2935 if (lock->lk_is_new) {
J. Bruce Fields599e0a22007-07-26 17:04:54 -04002936 if (!sop->so_is_open_owner)
2937 return nfserr_bad_stateid;
Andy Adamson60adfc52009-04-03 08:28:50 +03002938 if (!(flags & HAS_SESSION) &&
2939 !same_clid(&clp->cl_clientid, lockclid))
2940 return nfserr_bad_stateid;
J. Bruce Fields599e0a22007-07-26 17:04:54 -04002941 /* stp is the open stateid */
2942 status = nfs4_check_openmode(stp, lkflg);
2943 if (status)
2944 return status;
2945 } else {
2946 /* stp is the lock stateid */
2947 status = nfs4_check_openmode(stp->st_openstp, lkflg);
2948 if (status)
2949 return status;
NeilBrown4c4cd222005-07-07 17:59:27 -07002950 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002951 }
2952
J. Bruce Fieldsf3362732008-01-26 14:58:45 -05002953 if (nfs4_check_fh(current_fh, stp)) {
J. Bruce Fields2fdada02007-07-27 16:10:37 -04002954 dprintk("NFSD: preprocess_seqid_op: fh-stateid mismatch!\n");
NeilBrown3a4f98b2005-07-07 17:59:26 -07002955 return nfserr_bad_stateid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002956 }
2957
Linus Torvalds1da177e2005-04-16 15:20:36 -07002958 /*
2959 * We now validate the seqid and stateid generation numbers.
2960 * For the moment, we ignore the possibility of
2961 * generation number wraparound.
2962 */
Andy Adamson66689582009-04-03 08:28:45 +03002963 if (!(flags & HAS_SESSION) && seqid != sop->so_seqid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002964 goto check_replay;
2965
NeilBrown3a4f98b2005-07-07 17:59:26 -07002966 if (sop->so_confirmed && flags & CONFIRM) {
J. Bruce Fields2fdada02007-07-27 16:10:37 -04002967 dprintk("NFSD: preprocess_seqid_op: expected"
NeilBrown3a4f98b2005-07-07 17:59:26 -07002968 " unconfirmed stateowner!\n");
2969 return nfserr_bad_stateid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002970 }
NeilBrown3a4f98b2005-07-07 17:59:26 -07002971 if (!sop->so_confirmed && !(flags & CONFIRM)) {
J. Bruce Fields2fdada02007-07-27 16:10:37 -04002972 dprintk("NFSD: preprocess_seqid_op: stateowner not"
NeilBrown3a4f98b2005-07-07 17:59:26 -07002973 " confirmed yet!\n");
2974 return nfserr_bad_stateid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002975 }
Andy Adamson66689582009-04-03 08:28:45 +03002976 status = check_stateid_generation(stateid, &stp->st_stateid, flags);
J. Bruce Fields0836f582008-01-26 19:08:12 -05002977 if (status)
2978 return status;
NeilBrown52fd0042005-07-07 17:59:24 -07002979 renew_client(sop->so_client);
NeilBrown3a4f98b2005-07-07 17:59:26 -07002980 return nfs_ok;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002981
Linus Torvalds1da177e2005-04-16 15:20:36 -07002982check_replay:
NeilBrownbd9aac52005-07-07 17:59:19 -07002983 if (seqid == sop->so_seqid - 1) {
Neil Brown849823c2005-09-13 01:25:36 -07002984 dprintk("NFSD: preprocess_seqid_op: retransmission?\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002985 /* indicate replay to calling function */
Al Viroa90b0612006-10-19 23:29:03 -07002986 return nfserr_replay_me;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002987 }
J. Bruce Fields2fdada02007-07-27 16:10:37 -04002988 dprintk("NFSD: preprocess_seqid_op: bad seqid (expected %d, got %d)\n",
NeilBrown3a4f98b2005-07-07 17:59:26 -07002989 sop->so_seqid, seqid);
2990 *sopp = NULL;
2991 return nfserr_bad_seqid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002992}
2993
Al Virob37ad282006-10-19 23:28:59 -07002994__be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -08002995nfsd4_open_confirm(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
J.Bruce Fieldsa4f1706a92006-12-13 00:35:28 -08002996 struct nfsd4_open_confirm *oc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002997{
Al Virob37ad282006-10-19 23:28:59 -07002998 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002999 struct nfs4_stateowner *sop;
3000 struct nfs4_stateid *stp;
3001
3002 dprintk("NFSD: nfsd4_open_confirm on file %.*s\n",
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003003 (int)cstate->current_fh.fh_dentry->d_name.len,
3004 cstate->current_fh.fh_dentry->d_name.name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003005
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003006 status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0);
J. Bruce Fieldsa8cddc52006-06-30 01:56:13 -07003007 if (status)
3008 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003009
3010 nfs4_lock_state();
3011
Benny Halevydd453df2009-04-03 08:28:41 +03003012 if ((status = nfs4_preprocess_seqid_op(cstate,
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003013 oc->oc_seqid, &oc->oc_req_stateid,
J. Bruce Fieldsf3362732008-01-26 14:58:45 -05003014 CONFIRM | OPEN_STATE,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003015 &oc->oc_stateowner, &stp, NULL)))
3016 goto out;
3017
3018 sop = oc->oc_stateowner;
3019 sop->so_confirmed = 1;
3020 update_stateid(&stp->st_stateid);
3021 memcpy(&oc->oc_resp_stateid, &stp->st_stateid, sizeof(stateid_t));
3022 dprintk("NFSD: nfsd4_open_confirm: success, seqid=%d "
3023 "stateid=(%08x/%08x/%08x/%08x)\n", oc->oc_seqid,
3024 stp->st_stateid.si_boot,
3025 stp->st_stateid.si_stateownerid,
3026 stp->st_stateid.si_fileid,
3027 stp->st_stateid.si_generation);
NeilBrownc7b9a452005-06-23 22:04:30 -07003028
3029 nfsd4_create_clid_dir(sop->so_client);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003030out:
Neil Brownf2327d92005-09-13 01:25:37 -07003031 if (oc->oc_stateowner) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003032 nfs4_get_stateowner(oc->oc_stateowner);
J.Bruce Fieldsa4f1706a92006-12-13 00:35:28 -08003033 cstate->replay_owner = oc->oc_stateowner;
Neil Brownf2327d92005-09-13 01:25:37 -07003034 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003035 nfs4_unlock_state();
3036 return status;
3037}
3038
3039
3040/*
3041 * unset all bits in union bitmap (bmap) that
3042 * do not exist in share (from successful OPEN_DOWNGRADE)
3043 */
3044static void
3045reset_union_bmap_access(unsigned long access, unsigned long *bmap)
3046{
3047 int i;
3048 for (i = 1; i < 4; i++) {
3049 if ((i & access) != i)
3050 __clear_bit(i, bmap);
3051 }
3052}
3053
3054static void
3055reset_union_bmap_deny(unsigned long deny, unsigned long *bmap)
3056{
3057 int i;
3058 for (i = 0; i < 4; i++) {
3059 if ((i & deny) != i)
3060 __clear_bit(i, bmap);
3061 }
3062}
3063
Al Virob37ad282006-10-19 23:28:59 -07003064__be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003065nfsd4_open_downgrade(struct svc_rqst *rqstp,
3066 struct nfsd4_compound_state *cstate,
J.Bruce Fieldsa4f1706a92006-12-13 00:35:28 -08003067 struct nfsd4_open_downgrade *od)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003068{
Al Virob37ad282006-10-19 23:28:59 -07003069 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003070 struct nfs4_stateid *stp;
3071 unsigned int share_access;
3072
3073 dprintk("NFSD: nfsd4_open_downgrade on file %.*s\n",
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003074 (int)cstate->current_fh.fh_dentry->d_name.len,
3075 cstate->current_fh.fh_dentry->d_name.name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003076
Andy Adamsond87a8ad2009-04-03 08:28:53 +03003077 if (!access_valid(od->od_share_access, cstate->minorversion)
J. Bruce Fieldsba5a6a12006-06-30 01:56:16 -07003078 || !deny_valid(od->od_share_deny))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003079 return nfserr_inval;
3080
3081 nfs4_lock_state();
Benny Halevydd453df2009-04-03 08:28:41 +03003082 if ((status = nfs4_preprocess_seqid_op(cstate,
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003083 od->od_seqid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003084 &od->od_stateid,
J. Bruce Fieldsf3362732008-01-26 14:58:45 -05003085 OPEN_STATE,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003086 &od->od_stateowner, &stp, NULL)))
3087 goto out;
3088
3089 status = nfserr_inval;
3090 if (!test_bit(od->od_share_access, &stp->st_access_bmap)) {
3091 dprintk("NFSD:access not a subset current bitmap: 0x%lx, input access=%08x\n",
3092 stp->st_access_bmap, od->od_share_access);
3093 goto out;
3094 }
3095 if (!test_bit(od->od_share_deny, &stp->st_deny_bmap)) {
3096 dprintk("NFSD:deny not a subset current bitmap: 0x%lx, input deny=%08x\n",
3097 stp->st_deny_bmap, od->od_share_deny);
3098 goto out;
3099 }
3100 set_access(&share_access, stp->st_access_bmap);
3101 nfs4_file_downgrade(stp->st_vfs_file,
3102 share_access & ~od->od_share_access);
3103
3104 reset_union_bmap_access(od->od_share_access, &stp->st_access_bmap);
3105 reset_union_bmap_deny(od->od_share_deny, &stp->st_deny_bmap);
3106
3107 update_stateid(&stp->st_stateid);
3108 memcpy(&od->od_stateid, &stp->st_stateid, sizeof(stateid_t));
3109 status = nfs_ok;
3110out:
Neil Brownf2327d92005-09-13 01:25:37 -07003111 if (od->od_stateowner) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003112 nfs4_get_stateowner(od->od_stateowner);
J.Bruce Fieldsa4f1706a92006-12-13 00:35:28 -08003113 cstate->replay_owner = od->od_stateowner;
Neil Brownf2327d92005-09-13 01:25:37 -07003114 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003115 nfs4_unlock_state();
3116 return status;
3117}
3118
3119/*
3120 * nfs4_unlock_state() called after encode
3121 */
Al Virob37ad282006-10-19 23:28:59 -07003122__be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003123nfsd4_close(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
J.Bruce Fieldsa4f1706a92006-12-13 00:35:28 -08003124 struct nfsd4_close *close)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003125{
Al Virob37ad282006-10-19 23:28:59 -07003126 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003127 struct nfs4_stateid *stp;
3128
3129 dprintk("NFSD: nfsd4_close on file %.*s\n",
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003130 (int)cstate->current_fh.fh_dentry->d_name.len,
3131 cstate->current_fh.fh_dentry->d_name.name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003132
3133 nfs4_lock_state();
3134 /* check close_lru for replay */
Benny Halevydd453df2009-04-03 08:28:41 +03003135 if ((status = nfs4_preprocess_seqid_op(cstate,
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003136 close->cl_seqid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003137 &close->cl_stateid,
J. Bruce Fieldsf3362732008-01-26 14:58:45 -05003138 OPEN_STATE | CLOSE_STATE,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003139 &close->cl_stateowner, &stp, NULL)))
3140 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003141 status = nfs_ok;
3142 update_stateid(&stp->st_stateid);
3143 memcpy(&close->cl_stateid, &stp->st_stateid, sizeof(stateid_t));
3144
J. Bruce Fields04ef5952006-01-18 17:43:21 -08003145 /* release_stateid() calls nfsd_close() if needed */
J. Bruce Fields22839632009-01-11 14:27:17 -05003146 release_open_stateid(stp);
J. Bruce Fields04ef5952006-01-18 17:43:21 -08003147
3148 /* place unused nfs4_stateowners on so_close_lru list to be
3149 * released by the laundromat service after the lease period
3150 * to enable us to handle CLOSE replay
3151 */
3152 if (list_empty(&close->cl_stateowner->so_stateids))
3153 move_to_close_lru(close->cl_stateowner);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003154out:
Neil Brownf2327d92005-09-13 01:25:37 -07003155 if (close->cl_stateowner) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003156 nfs4_get_stateowner(close->cl_stateowner);
J.Bruce Fieldsa4f1706a92006-12-13 00:35:28 -08003157 cstate->replay_owner = close->cl_stateowner;
Neil Brownf2327d92005-09-13 01:25:37 -07003158 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003159 nfs4_unlock_state();
3160 return status;
3161}
3162
Al Virob37ad282006-10-19 23:28:59 -07003163__be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003164nfsd4_delegreturn(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
3165 struct nfsd4_delegreturn *dr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003166{
J. Bruce Fields203a8c82009-02-21 13:29:14 -08003167 struct nfs4_delegation *dp;
3168 stateid_t *stateid = &dr->dr_stateid;
3169 struct inode *inode;
Al Virob37ad282006-10-19 23:28:59 -07003170 __be32 status;
Andy Adamson66689582009-04-03 08:28:45 +03003171 int flags = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003172
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003173 if ((status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0)))
J. Bruce Fields203a8c82009-02-21 13:29:14 -08003174 return status;
3175 inode = cstate->current_fh.fh_dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003176
Andy Adamson66689582009-04-03 08:28:45 +03003177 if (nfsd4_has_session(cstate))
3178 flags |= HAS_SESSION;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003179 nfs4_lock_state();
J. Bruce Fields203a8c82009-02-21 13:29:14 -08003180 status = nfserr_bad_stateid;
3181 if (ZERO_STATEID(stateid) || ONE_STATEID(stateid))
3182 goto out;
3183 status = nfserr_stale_stateid;
3184 if (STALE_STATEID(stateid))
3185 goto out;
J. Bruce Fields7e0f7cf2009-02-21 13:32:28 -08003186 status = nfserr_bad_stateid;
J. Bruce Fields203a8c82009-02-21 13:29:14 -08003187 if (!is_delegation_stateid(stateid))
3188 goto out;
J. Bruce Fields203a8c82009-02-21 13:29:14 -08003189 dp = find_delegation_stateid(inode, stateid);
Bian Naimeng78155ed2009-04-22 18:25:37 +08003190 if (!dp) {
3191 status = stateid_error_map(stateid);
J. Bruce Fields203a8c82009-02-21 13:29:14 -08003192 goto out;
Bian Naimeng78155ed2009-04-22 18:25:37 +08003193 }
Andy Adamson66689582009-04-03 08:28:45 +03003194 status = check_stateid_generation(stateid, &dp->dl_stateid, flags);
J. Bruce Fields203a8c82009-02-21 13:29:14 -08003195 if (status)
3196 goto out;
3197 renew_client(dp->dl_client);
3198
3199 unhash_delegation(dp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003200out:
J. Bruce Fields203a8c82009-02-21 13:29:14 -08003201 nfs4_unlock_state();
3202
Linus Torvalds1da177e2005-04-16 15:20:36 -07003203 return status;
3204}
3205
3206
3207/*
3208 * Lock owner state (byte-range locks)
3209 */
3210#define LOFF_OVERFLOW(start, len) ((u64)(len) > ~(u64)(start))
3211#define LOCK_HASH_BITS 8
3212#define LOCK_HASH_SIZE (1 << LOCK_HASH_BITS)
3213#define LOCK_HASH_MASK (LOCK_HASH_SIZE - 1)
3214
Benny Halevy87df4de2008-12-15 19:42:03 +02003215static inline u64
3216end_offset(u64 start, u64 len)
3217{
3218 u64 end;
3219
3220 end = start + len;
3221 return end >= start ? end: NFS4_MAX_UINT64;
3222}
3223
3224/* last octet in a range */
3225static inline u64
3226last_byte_offset(u64 start, u64 len)
3227{
3228 u64 end;
3229
3230 BUG_ON(!len);
3231 end = start + len;
3232 return end > start ? end - 1: NFS4_MAX_UINT64;
3233}
3234
Linus Torvalds1da177e2005-04-16 15:20:36 -07003235#define lockownerid_hashval(id) \
3236 ((id) & LOCK_HASH_MASK)
3237
3238static inline unsigned int
3239lock_ownerstr_hashval(struct inode *inode, u32 cl_id,
3240 struct xdr_netobj *ownername)
3241{
3242 return (file_hashval(inode) + cl_id
3243 + opaque_hashval(ownername->data, ownername->len))
3244 & LOCK_HASH_MASK;
3245}
3246
3247static struct list_head lock_ownerid_hashtbl[LOCK_HASH_SIZE];
3248static struct list_head lock_ownerstr_hashtbl[LOCK_HASH_SIZE];
3249static struct list_head lockstateid_hashtbl[STATEID_HASH_SIZE];
3250
NeilBrownfd39ca92005-06-23 22:04:03 -07003251static struct nfs4_stateid *
Linus Torvalds1da177e2005-04-16 15:20:36 -07003252find_stateid(stateid_t *stid, int flags)
3253{
Krishna Kumar9346eff2008-10-20 11:44:28 +05303254 struct nfs4_stateid *local;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003255 u32 st_id = stid->si_stateownerid;
3256 u32 f_id = stid->si_fileid;
3257 unsigned int hashval;
3258
3259 dprintk("NFSD: find_stateid flags 0x%x\n",flags);
Krishna Kumar9346eff2008-10-20 11:44:28 +05303260 if (flags & (LOCK_STATE | RD_STATE | WR_STATE)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003261 hashval = stateid_hashval(st_id, f_id);
3262 list_for_each_entry(local, &lockstateid_hashtbl[hashval], st_hash) {
3263 if ((local->st_stateid.si_stateownerid == st_id) &&
3264 (local->st_stateid.si_fileid == f_id))
3265 return local;
3266 }
3267 }
Krishna Kumar9346eff2008-10-20 11:44:28 +05303268
3269 if (flags & (OPEN_STATE | RD_STATE | WR_STATE)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003270 hashval = stateid_hashval(st_id, f_id);
3271 list_for_each_entry(local, &stateid_hashtbl[hashval], st_hash) {
3272 if ((local->st_stateid.si_stateownerid == st_id) &&
3273 (local->st_stateid.si_fileid == f_id))
3274 return local;
3275 }
Neil Brown849823c2005-09-13 01:25:36 -07003276 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003277 return NULL;
3278}
3279
3280static struct nfs4_delegation *
3281find_delegation_stateid(struct inode *ino, stateid_t *stid)
3282{
NeilBrown13cd2182005-06-23 22:03:10 -07003283 struct nfs4_file *fp;
3284 struct nfs4_delegation *dl;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003285
3286 dprintk("NFSD:find_delegation_stateid stateid=(%08x/%08x/%08x/%08x)\n",
3287 stid->si_boot, stid->si_stateownerid,
3288 stid->si_fileid, stid->si_generation);
3289
Linus Torvalds1da177e2005-04-16 15:20:36 -07003290 fp = find_file(ino);
NeilBrown13cd2182005-06-23 22:03:10 -07003291 if (!fp)
3292 return NULL;
3293 dl = find_delegation_file(fp, stid);
3294 put_nfs4_file(fp);
3295 return dl;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003296}
3297
3298/*
3299 * TODO: Linux file offsets are _signed_ 64-bit quantities, which means that
3300 * we can't properly handle lock requests that go beyond the (2^63 - 1)-th
3301 * byte, because of sign extension problems. Since NFSv4 calls for 64-bit
3302 * locking, this prevents us from being completely protocol-compliant. The
3303 * real solution to this problem is to start using unsigned file offsets in
3304 * the VFS, but this is a very deep change!
3305 */
3306static inline void
3307nfs4_transform_lock_offset(struct file_lock *lock)
3308{
3309 if (lock->fl_start < 0)
3310 lock->fl_start = OFFSET_MAX;
3311 if (lock->fl_end < 0)
3312 lock->fl_end = OFFSET_MAX;
3313}
3314
NeilBrownd5b90262006-04-10 22:55:22 -07003315/* Hack!: For now, we're defining this just so we can use a pointer to it
3316 * as a unique cookie to identify our (NFSv4's) posix locks. */
Alexey Dobriyan7b021962009-09-21 17:01:12 -07003317static const struct lock_manager_operations nfsd_posix_mng_ops = {
NeilBrownd5b90262006-04-10 22:55:22 -07003318};
Linus Torvalds1da177e2005-04-16 15:20:36 -07003319
3320static inline void
3321nfs4_set_lock_denied(struct file_lock *fl, struct nfsd4_lock_denied *deny)
3322{
NeilBrownd5b90262006-04-10 22:55:22 -07003323 struct nfs4_stateowner *sop;
3324 unsigned int hval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003325
NeilBrownd5b90262006-04-10 22:55:22 -07003326 if (fl->fl_lmops == &nfsd_posix_mng_ops) {
3327 sop = (struct nfs4_stateowner *) fl->fl_owner;
3328 hval = lockownerid_hashval(sop->so_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003329 kref_get(&sop->so_ref);
3330 deny->ld_sop = sop;
3331 deny->ld_clientid = sop->so_client->cl_clientid;
NeilBrownd5b90262006-04-10 22:55:22 -07003332 } else {
3333 deny->ld_sop = NULL;
3334 deny->ld_clientid.cl_boot = 0;
3335 deny->ld_clientid.cl_id = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003336 }
3337 deny->ld_start = fl->fl_start;
Benny Halevy87df4de2008-12-15 19:42:03 +02003338 deny->ld_length = NFS4_MAX_UINT64;
3339 if (fl->fl_end != NFS4_MAX_UINT64)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003340 deny->ld_length = fl->fl_end - fl->fl_start + 1;
3341 deny->ld_type = NFS4_READ_LT;
3342 if (fl->fl_type != F_RDLCK)
3343 deny->ld_type = NFS4_WRITE_LT;
3344}
3345
3346static struct nfs4_stateowner *
Linus Torvalds1da177e2005-04-16 15:20:36 -07003347find_lockstateowner_str(struct inode *inode, clientid_t *clid,
3348 struct xdr_netobj *owner)
3349{
3350 unsigned int hashval = lock_ownerstr_hashval(inode, clid->cl_id, owner);
3351 struct nfs4_stateowner *op;
3352
3353 list_for_each_entry(op, &lock_ownerstr_hashtbl[hashval], so_strhash) {
J. Bruce Fields599e0a22007-07-26 17:04:54 -04003354 if (same_owner_str(op, owner, clid))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003355 return op;
3356 }
3357 return NULL;
3358}
3359
3360/*
3361 * Alloc a lock owner structure.
3362 * Called in nfsd4_lock - therefore, OPEN and OPEN_CONFIRM (if needed) has
3363 * occured.
3364 *
3365 * strhashval = lock_ownerstr_hashval
Linus Torvalds1da177e2005-04-16 15:20:36 -07003366 */
3367
3368static struct nfs4_stateowner *
3369alloc_init_lock_stateowner(unsigned int strhashval, struct nfs4_client *clp, struct nfs4_stateid *open_stp, struct nfsd4_lock *lock) {
3370 struct nfs4_stateowner *sop;
3371 struct nfs4_replay *rp;
3372 unsigned int idhashval;
3373
3374 if (!(sop = alloc_stateowner(&lock->lk_new_owner)))
3375 return NULL;
3376 idhashval = lockownerid_hashval(current_ownerid);
3377 INIT_LIST_HEAD(&sop->so_idhash);
3378 INIT_LIST_HEAD(&sop->so_strhash);
3379 INIT_LIST_HEAD(&sop->so_perclient);
NeilBrownea1da632005-06-23 22:04:17 -07003380 INIT_LIST_HEAD(&sop->so_stateids);
3381 INIT_LIST_HEAD(&sop->so_perstateid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003382 INIT_LIST_HEAD(&sop->so_close_lru); /* not used */
3383 sop->so_time = 0;
3384 list_add(&sop->so_idhash, &lock_ownerid_hashtbl[idhashval]);
3385 list_add(&sop->so_strhash, &lock_ownerstr_hashtbl[strhashval]);
NeilBrownea1da632005-06-23 22:04:17 -07003386 list_add(&sop->so_perstateid, &open_stp->st_lockowners);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003387 sop->so_is_open_owner = 0;
3388 sop->so_id = current_ownerid++;
3389 sop->so_client = clp;
Neil Brownb59e3c02005-09-13 01:25:38 -07003390 /* It is the openowner seqid that will be incremented in encode in the
3391 * case of new lockowners; so increment the lock seqid manually: */
3392 sop->so_seqid = lock->lk_new_lock_seqid + 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003393 sop->so_confirmed = 1;
3394 rp = &sop->so_replay;
Al Virode1ae282006-01-18 17:43:47 -08003395 rp->rp_status = nfserr_serverfault;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003396 rp->rp_buflen = 0;
3397 rp->rp_buf = rp->rp_ibuf;
3398 return sop;
3399}
3400
NeilBrownfd39ca92005-06-23 22:04:03 -07003401static struct nfs4_stateid *
Linus Torvalds1da177e2005-04-16 15:20:36 -07003402alloc_init_lock_stateid(struct nfs4_stateowner *sop, struct nfs4_file *fp, struct nfs4_stateid *open_stp)
3403{
3404 struct nfs4_stateid *stp;
3405 unsigned int hashval = stateid_hashval(sop->so_id, fp->fi_id);
3406
NeilBrown5ac049a2005-06-23 22:03:03 -07003407 stp = nfs4_alloc_stateid();
3408 if (stp == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003409 goto out;
3410 INIT_LIST_HEAD(&stp->st_hash);
3411 INIT_LIST_HEAD(&stp->st_perfile);
NeilBrownea1da632005-06-23 22:04:17 -07003412 INIT_LIST_HEAD(&stp->st_perstateowner);
3413 INIT_LIST_HEAD(&stp->st_lockowners); /* not used */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003414 list_add(&stp->st_hash, &lockstateid_hashtbl[hashval]);
NeilBrown8beefa22005-06-23 22:03:08 -07003415 list_add(&stp->st_perfile, &fp->fi_stateids);
NeilBrownea1da632005-06-23 22:04:17 -07003416 list_add(&stp->st_perstateowner, &sop->so_stateids);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003417 stp->st_stateowner = sop;
NeilBrown13cd2182005-06-23 22:03:10 -07003418 get_nfs4_file(fp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003419 stp->st_file = fp;
Bian Naimeng78155ed2009-04-22 18:25:37 +08003420 stp->st_stateid.si_boot = get_seconds();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003421 stp->st_stateid.si_stateownerid = sop->so_id;
3422 stp->st_stateid.si_fileid = fp->fi_id;
3423 stp->st_stateid.si_generation = 0;
3424 stp->st_vfs_file = open_stp->st_vfs_file; /* FIXME refcount?? */
3425 stp->st_access_bmap = open_stp->st_access_bmap;
3426 stp->st_deny_bmap = open_stp->st_deny_bmap;
NeilBrown4c4cd222005-07-07 17:59:27 -07003427 stp->st_openstp = open_stp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003428
3429out:
3430 return stp;
3431}
3432
NeilBrownfd39ca92005-06-23 22:04:03 -07003433static int
Linus Torvalds1da177e2005-04-16 15:20:36 -07003434check_lock_length(u64 offset, u64 length)
3435{
Benny Halevy87df4de2008-12-15 19:42:03 +02003436 return ((length == 0) || ((length != NFS4_MAX_UINT64) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07003437 LOFF_OVERFLOW(offset, length)));
3438}
3439
3440/*
3441 * LOCK operation
3442 */
Al Virob37ad282006-10-19 23:28:59 -07003443__be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003444nfsd4_lock(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
J.Bruce Fieldsa4f1706a92006-12-13 00:35:28 -08003445 struct nfsd4_lock *lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003446{
NeilBrown3e9e3db2005-06-23 22:04:20 -07003447 struct nfs4_stateowner *open_sop = NULL;
Neil Brownb59e3c02005-09-13 01:25:38 -07003448 struct nfs4_stateowner *lock_sop = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003449 struct nfs4_stateid *lock_stp;
3450 struct file *filp;
3451 struct file_lock file_lock;
Andy Adamson8dc7c312006-03-20 13:44:26 -05003452 struct file_lock conflock;
Al Virob37ad282006-10-19 23:28:59 -07003453 __be32 status = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003454 unsigned int strhashval;
Marc Eshel150b3932007-01-18 16:15:35 -05003455 unsigned int cmd;
Al Virob8dd7b92006-10-19 23:29:01 -07003456 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003457
3458 dprintk("NFSD: nfsd4_lock: start=%Ld length=%Ld\n",
3459 (long long) lock->lk_offset,
3460 (long long) lock->lk_length);
3461
Linus Torvalds1da177e2005-04-16 15:20:36 -07003462 if (check_lock_length(lock->lk_offset, lock->lk_length))
3463 return nfserr_inval;
3464
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003465 if ((status = fh_verify(rqstp, &cstate->current_fh,
Miklos Szeredi8837abc2008-06-16 13:20:29 +02003466 S_IFREG, NFSD_MAY_LOCK))) {
Andy Adamsona6f6ef22006-01-18 17:43:17 -08003467 dprintk("NFSD: nfsd4_lock: permission denied!\n");
3468 return status;
3469 }
3470
Linus Torvalds1da177e2005-04-16 15:20:36 -07003471 nfs4_lock_state();
3472
3473 if (lock->lk_is_new) {
NeilBrown893f8772005-07-07 17:59:17 -07003474 /*
3475 * Client indicates that this is a new lockowner.
3476 * Use open owner and open stateid to create lock owner and
3477 * lock stateid.
3478 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003479 struct nfs4_stateid *open_stp = NULL;
3480 struct nfs4_file *fp;
3481
3482 status = nfserr_stale_clientid;
Andy Adamson60adfc52009-04-03 08:28:50 +03003483 if (!nfsd4_has_session(cstate) &&
3484 STALE_CLIENTID(&lock->lk_new_clientid))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003485 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003486
Linus Torvalds1da177e2005-04-16 15:20:36 -07003487 /* validate and update open stateid and open seqid */
Benny Halevydd453df2009-04-03 08:28:41 +03003488 status = nfs4_preprocess_seqid_op(cstate,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003489 lock->lk_new_open_seqid,
3490 &lock->lk_new_open_stateid,
J. Bruce Fieldsf3362732008-01-26 14:58:45 -05003491 OPEN_STATE,
J. Bruce Fields3a655882006-01-18 17:43:19 -08003492 &lock->lk_replay_owner, &open_stp,
Neil Brownb59e3c02005-09-13 01:25:38 -07003493 lock);
NeilBrown37515172005-07-07 17:59:16 -07003494 if (status)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003495 goto out;
J. Bruce Fields3a655882006-01-18 17:43:19 -08003496 open_sop = lock->lk_replay_owner;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003497 /* create lockowner and lock stateid */
3498 fp = open_stp->st_file;
3499 strhashval = lock_ownerstr_hashval(fp->fi_inode,
3500 open_sop->so_client->cl_clientid.cl_id,
3501 &lock->v.new.owner);
NeilBrown3e9e3db2005-06-23 22:04:20 -07003502 /* XXX: Do we need to check for duplicate stateowners on
3503 * the same file, or should they just be allowed (and
3504 * create new stateids)? */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003505 status = nfserr_resource;
Neil Brownb59e3c02005-09-13 01:25:38 -07003506 lock_sop = alloc_init_lock_stateowner(strhashval,
3507 open_sop->so_client, open_stp, lock);
3508 if (lock_sop == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003509 goto out;
Neil Brownb59e3c02005-09-13 01:25:38 -07003510 lock_stp = alloc_init_lock_stateid(lock_sop, fp, open_stp);
J. Bruce Fields8a280512006-01-18 17:43:18 -08003511 if (lock_stp == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003512 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003513 } else {
3514 /* lock (lock owner + lock stateid) already exists */
Benny Halevydd453df2009-04-03 08:28:41 +03003515 status = nfs4_preprocess_seqid_op(cstate,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003516 lock->lk_old_lock_seqid,
3517 &lock->lk_old_lock_stateid,
J. Bruce Fieldsf3362732008-01-26 14:58:45 -05003518 LOCK_STATE,
J. Bruce Fields3a655882006-01-18 17:43:19 -08003519 &lock->lk_replay_owner, &lock_stp, lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003520 if (status)
3521 goto out;
J. Bruce Fields3a655882006-01-18 17:43:19 -08003522 lock_sop = lock->lk_replay_owner;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003523 }
J. Bruce Fields3a655882006-01-18 17:43:19 -08003524 /* lock->lk_replay_owner and lock_stp have been created or found */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003525 filp = lock_stp->st_vfs_file;
3526
NeilBrown0dd395d2005-07-07 17:59:15 -07003527 status = nfserr_grace;
J. Bruce Fieldsaf558e32007-09-06 12:34:25 -04003528 if (locks_in_grace() && !lock->lk_reclaim)
NeilBrown0dd395d2005-07-07 17:59:15 -07003529 goto out;
3530 status = nfserr_no_grace;
J. Bruce Fieldsaf558e32007-09-06 12:34:25 -04003531 if (!locks_in_grace() && lock->lk_reclaim)
NeilBrown0dd395d2005-07-07 17:59:15 -07003532 goto out;
3533
Linus Torvalds1da177e2005-04-16 15:20:36 -07003534 locks_init_lock(&file_lock);
3535 switch (lock->lk_type) {
3536 case NFS4_READ_LT:
3537 case NFS4_READW_LT:
3538 file_lock.fl_type = F_RDLCK;
Marc Eshel150b3932007-01-18 16:15:35 -05003539 cmd = F_SETLK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003540 break;
3541 case NFS4_WRITE_LT:
3542 case NFS4_WRITEW_LT:
3543 file_lock.fl_type = F_WRLCK;
Marc Eshel150b3932007-01-18 16:15:35 -05003544 cmd = F_SETLK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003545 break;
3546 default:
3547 status = nfserr_inval;
3548 goto out;
3549 }
Neil Brownb59e3c02005-09-13 01:25:38 -07003550 file_lock.fl_owner = (fl_owner_t)lock_sop;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003551 file_lock.fl_pid = current->tgid;
3552 file_lock.fl_file = filp;
3553 file_lock.fl_flags = FL_POSIX;
NeilBrownd5b90262006-04-10 22:55:22 -07003554 file_lock.fl_lmops = &nfsd_posix_mng_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003555
3556 file_lock.fl_start = lock->lk_offset;
Benny Halevy87df4de2008-12-15 19:42:03 +02003557 file_lock.fl_end = last_byte_offset(lock->lk_offset, lock->lk_length);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003558 nfs4_transform_lock_offset(&file_lock);
3559
3560 /*
3561 * Try to lock the file in the VFS.
3562 * Note: locks.c uses the BKL to protect the inode's lock list.
3563 */
3564
Marc Eshelfd85b812006-11-28 16:26:41 -05003565 err = vfs_lock_file(filp, cmd, &file_lock, &conflock);
Al Virob8dd7b92006-10-19 23:29:01 -07003566 switch (-err) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003567 case 0: /* success! */
3568 update_stateid(&lock_stp->st_stateid);
3569 memcpy(&lock->lk_resp_stateid, &lock_stp->st_stateid,
3570 sizeof(stateid_t));
Al Virob8dd7b92006-10-19 23:29:01 -07003571 status = 0;
Andy Adamsoneb76b3f2006-03-26 01:37:26 -08003572 break;
3573 case (EAGAIN): /* conflock holds conflicting lock */
3574 status = nfserr_denied;
3575 dprintk("NFSD: nfsd4_lock: conflicting lock found!\n");
3576 nfs4_set_lock_denied(&conflock, &lock->lk_denied);
3577 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003578 case (EDEADLK):
3579 status = nfserr_deadlock;
Andy Adamsoneb76b3f2006-03-26 01:37:26 -08003580 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003581 default:
Marc Eshelfd85b812006-11-28 16:26:41 -05003582 dprintk("NFSD: nfsd4_lock: vfs_lock_file() failed! status %d\n",err);
Andy Adamsoneb76b3f2006-03-26 01:37:26 -08003583 status = nfserr_resource;
3584 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003585 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003586out:
J. Bruce Fields8a280512006-01-18 17:43:18 -08003587 if (status && lock->lk_is_new && lock_sop)
J. Bruce Fieldsf044ff82009-01-11 15:24:04 -05003588 release_lockowner(lock_sop);
J. Bruce Fields3a655882006-01-18 17:43:19 -08003589 if (lock->lk_replay_owner) {
3590 nfs4_get_stateowner(lock->lk_replay_owner);
J.Bruce Fieldsa4f1706a92006-12-13 00:35:28 -08003591 cstate->replay_owner = lock->lk_replay_owner;
Neil Brownf2327d92005-09-13 01:25:37 -07003592 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003593 nfs4_unlock_state();
3594 return status;
3595}
3596
3597/*
J. Bruce Fields55ef1272008-12-20 11:58:38 -08003598 * The NFSv4 spec allows a client to do a LOCKT without holding an OPEN,
3599 * so we do a temporary open here just to get an open file to pass to
3600 * vfs_test_lock. (Arguably perhaps test_lock should be done with an
3601 * inode operation.)
3602 */
3603static int nfsd_test_lock(struct svc_rqst *rqstp, struct svc_fh *fhp, struct file_lock *lock)
3604{
3605 struct file *file;
3606 int err;
3607
3608 err = nfsd_open(rqstp, fhp, S_IFREG, NFSD_MAY_READ, &file);
3609 if (err)
3610 return err;
3611 err = vfs_test_lock(file, lock);
3612 nfsd_close(file);
3613 return err;
3614}
3615
3616/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07003617 * LOCKT operation
3618 */
Al Virob37ad282006-10-19 23:28:59 -07003619__be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003620nfsd4_lockt(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
3621 struct nfsd4_lockt *lockt)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003622{
3623 struct inode *inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003624 struct file_lock file_lock;
Marc Eshelfd85b812006-11-28 16:26:41 -05003625 int error;
Al Virob37ad282006-10-19 23:28:59 -07003626 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003627
J. Bruce Fieldsaf558e32007-09-06 12:34:25 -04003628 if (locks_in_grace())
Linus Torvalds1da177e2005-04-16 15:20:36 -07003629 return nfserr_grace;
3630
3631 if (check_lock_length(lockt->lt_offset, lockt->lt_length))
3632 return nfserr_inval;
3633
3634 lockt->lt_stateowner = NULL;
3635 nfs4_lock_state();
3636
3637 status = nfserr_stale_clientid;
Andy Adamson60adfc52009-04-03 08:28:50 +03003638 if (!nfsd4_has_session(cstate) && STALE_CLIENTID(&lockt->lt_clientid))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003639 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003640
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003641 if ((status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0))) {
Neil Brown849823c2005-09-13 01:25:36 -07003642 dprintk("NFSD: nfsd4_lockt: fh_verify() failed!\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003643 if (status == nfserr_symlink)
3644 status = nfserr_inval;
3645 goto out;
3646 }
3647
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003648 inode = cstate->current_fh.fh_dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003649 locks_init_lock(&file_lock);
3650 switch (lockt->lt_type) {
3651 case NFS4_READ_LT:
3652 case NFS4_READW_LT:
3653 file_lock.fl_type = F_RDLCK;
3654 break;
3655 case NFS4_WRITE_LT:
3656 case NFS4_WRITEW_LT:
3657 file_lock.fl_type = F_WRLCK;
3658 break;
3659 default:
J. Bruce Fields2fdada02007-07-27 16:10:37 -04003660 dprintk("NFSD: nfs4_lockt: bad lock type!\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003661 status = nfserr_inval;
3662 goto out;
3663 }
3664
3665 lockt->lt_stateowner = find_lockstateowner_str(inode,
3666 &lockt->lt_clientid, &lockt->lt_owner);
3667 if (lockt->lt_stateowner)
3668 file_lock.fl_owner = (fl_owner_t)lockt->lt_stateowner;
3669 file_lock.fl_pid = current->tgid;
3670 file_lock.fl_flags = FL_POSIX;
3671
3672 file_lock.fl_start = lockt->lt_offset;
Benny Halevy87df4de2008-12-15 19:42:03 +02003673 file_lock.fl_end = last_byte_offset(lockt->lt_offset, lockt->lt_length);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003674
3675 nfs4_transform_lock_offset(&file_lock);
3676
Linus Torvalds1da177e2005-04-16 15:20:36 -07003677 status = nfs_ok;
J. Bruce Fields55ef1272008-12-20 11:58:38 -08003678 error = nfsd_test_lock(rqstp, &cstate->current_fh, &file_lock);
Marc Eshelfd85b812006-11-28 16:26:41 -05003679 if (error) {
3680 status = nfserrno(error);
3681 goto out;
3682 }
Marc Eshel9d6a8c52007-02-21 00:55:18 -05003683 if (file_lock.fl_type != F_UNLCK) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003684 status = nfserr_denied;
Marc Eshel9d6a8c52007-02-21 00:55:18 -05003685 nfs4_set_lock_denied(&file_lock, &lockt->lt_denied);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003686 }
3687out:
3688 nfs4_unlock_state();
3689 return status;
3690}
3691
Al Virob37ad282006-10-19 23:28:59 -07003692__be32
J.Bruce Fieldsca364312006-12-13 00:35:27 -08003693nfsd4_locku(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
J.Bruce Fieldsa4f1706a92006-12-13 00:35:28 -08003694 struct nfsd4_locku *locku)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003695{
3696 struct nfs4_stateid *stp;
3697 struct file *filp = NULL;
3698 struct file_lock file_lock;
Al Virob37ad282006-10-19 23:28:59 -07003699 __be32 status;
Al Virob8dd7b92006-10-19 23:29:01 -07003700 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003701
3702 dprintk("NFSD: nfsd4_locku: start=%Ld length=%Ld\n",
3703 (long long) locku->lu_offset,
3704 (long long) locku->lu_length);
3705
3706 if (check_lock_length(locku->lu_offset, locku->lu_length))
3707 return nfserr_inval;
3708
3709 nfs4_lock_state();
3710
Benny Halevydd453df2009-04-03 08:28:41 +03003711 if ((status = nfs4_preprocess_seqid_op(cstate,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003712 locku->lu_seqid,
3713 &locku->lu_stateid,
J. Bruce Fieldsf3362732008-01-26 14:58:45 -05003714 LOCK_STATE,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003715 &locku->lu_stateowner, &stp, NULL)))
3716 goto out;
3717
3718 filp = stp->st_vfs_file;
3719 BUG_ON(!filp);
3720 locks_init_lock(&file_lock);
3721 file_lock.fl_type = F_UNLCK;
3722 file_lock.fl_owner = (fl_owner_t) locku->lu_stateowner;
3723 file_lock.fl_pid = current->tgid;
3724 file_lock.fl_file = filp;
3725 file_lock.fl_flags = FL_POSIX;
NeilBrownd5b90262006-04-10 22:55:22 -07003726 file_lock.fl_lmops = &nfsd_posix_mng_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003727 file_lock.fl_start = locku->lu_offset;
3728
Benny Halevy87df4de2008-12-15 19:42:03 +02003729 file_lock.fl_end = last_byte_offset(locku->lu_offset, locku->lu_length);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003730 nfs4_transform_lock_offset(&file_lock);
3731
3732 /*
3733 * Try to unlock the file in the VFS.
3734 */
Marc Eshelfd85b812006-11-28 16:26:41 -05003735 err = vfs_lock_file(filp, F_SETLK, &file_lock, NULL);
Al Virob8dd7b92006-10-19 23:29:01 -07003736 if (err) {
Marc Eshelfd85b812006-11-28 16:26:41 -05003737 dprintk("NFSD: nfs4_locku: vfs_lock_file failed!\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003738 goto out_nfserr;
3739 }
3740 /*
3741 * OK, unlock succeeded; the only thing left to do is update the stateid.
3742 */
3743 update_stateid(&stp->st_stateid);
3744 memcpy(&locku->lu_stateid, &stp->st_stateid, sizeof(stateid_t));
3745
3746out:
Neil Brownf2327d92005-09-13 01:25:37 -07003747 if (locku->lu_stateowner) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003748 nfs4_get_stateowner(locku->lu_stateowner);
J.Bruce Fieldsa4f1706a92006-12-13 00:35:28 -08003749 cstate->replay_owner = locku->lu_stateowner;
Neil Brownf2327d92005-09-13 01:25:37 -07003750 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003751 nfs4_unlock_state();
3752 return status;
3753
3754out_nfserr:
Al Virob8dd7b92006-10-19 23:29:01 -07003755 status = nfserrno(err);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003756 goto out;
3757}
3758
3759/*
3760 * returns
3761 * 1: locks held by lockowner
3762 * 0: no locks held by lockowner
3763 */
3764static int
3765check_for_locks(struct file *filp, struct nfs4_stateowner *lowner)
3766{
3767 struct file_lock **flpp;
Josef "Jeff" Sipek7eaa36e2006-12-08 02:36:41 -08003768 struct inode *inode = filp->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003769 int status = 0;
3770
3771 lock_kernel();
3772 for (flpp = &inode->i_flock; *flpp != NULL; flpp = &(*flpp)->fl_next) {
J. Bruce Fields796dadf2006-01-18 17:43:22 -08003773 if ((*flpp)->fl_owner == (fl_owner_t)lowner) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003774 status = 1;
3775 goto out;
J. Bruce Fields796dadf2006-01-18 17:43:22 -08003776 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003777 }
3778out:
3779 unlock_kernel();
3780 return status;
3781}
3782
Al Virob37ad282006-10-19 23:28:59 -07003783__be32
J.Bruce Fieldsb5914802006-12-13 00:35:38 -08003784nfsd4_release_lockowner(struct svc_rqst *rqstp,
3785 struct nfsd4_compound_state *cstate,
3786 struct nfsd4_release_lockowner *rlockowner)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003787{
3788 clientid_t *clid = &rlockowner->rl_clientid;
NeilBrown3e9e3db2005-06-23 22:04:20 -07003789 struct nfs4_stateowner *sop;
3790 struct nfs4_stateid *stp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003791 struct xdr_netobj *owner = &rlockowner->rl_owner;
NeilBrown3e9e3db2005-06-23 22:04:20 -07003792 struct list_head matches;
3793 int i;
Al Virob37ad282006-10-19 23:28:59 -07003794 __be32 status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003795
3796 dprintk("nfsd4_release_lockowner clientid: (%08x/%08x):\n",
3797 clid->cl_boot, clid->cl_id);
3798
3799 /* XXX check for lease expiration */
3800
3801 status = nfserr_stale_clientid;
Neil Brown849823c2005-09-13 01:25:36 -07003802 if (STALE_CLIENTID(clid))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003803 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003804
3805 nfs4_lock_state();
3806
NeilBrown3e9e3db2005-06-23 22:04:20 -07003807 status = nfserr_locks_held;
3808 /* XXX: we're doing a linear search through all the lockowners.
3809 * Yipes! For now we'll just hope clients aren't really using
3810 * release_lockowner much, but eventually we have to fix these
3811 * data structures. */
3812 INIT_LIST_HEAD(&matches);
3813 for (i = 0; i < LOCK_HASH_SIZE; i++) {
3814 list_for_each_entry(sop, &lock_ownerid_hashtbl[i], so_idhash) {
J. Bruce Fields599e0a22007-07-26 17:04:54 -04003815 if (!same_owner_str(sop, owner, clid))
NeilBrown3e9e3db2005-06-23 22:04:20 -07003816 continue;
3817 list_for_each_entry(stp, &sop->so_stateids,
3818 st_perstateowner) {
3819 if (check_for_locks(stp->st_vfs_file, sop))
3820 goto out;
3821 /* Note: so_perclient unused for lockowners,
3822 * so it's OK to fool with here. */
3823 list_add(&sop->so_perclient, &matches);
3824 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003825 }
NeilBrown3e9e3db2005-06-23 22:04:20 -07003826 }
3827 /* Clients probably won't expect us to return with some (but not all)
3828 * of the lockowner state released; so don't release any until all
3829 * have been checked. */
3830 status = nfs_ok;
NeilBrown0fa822e2005-07-07 17:59:14 -07003831 while (!list_empty(&matches)) {
3832 sop = list_entry(matches.next, struct nfs4_stateowner,
3833 so_perclient);
3834 /* unhash_stateowner deletes so_perclient only
3835 * for openowners. */
3836 list_del(&sop->so_perclient);
J. Bruce Fieldsf044ff82009-01-11 15:24:04 -05003837 release_lockowner(sop);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003838 }
3839out:
3840 nfs4_unlock_state();
3841 return status;
3842}
3843
3844static inline struct nfs4_client_reclaim *
NeilBrowna55370a2005-06-23 22:03:52 -07003845alloc_reclaim(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003846{
NeilBrowna55370a2005-06-23 22:03:52 -07003847 return kmalloc(sizeof(struct nfs4_client_reclaim), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003848}
3849
NeilBrownc7b9a452005-06-23 22:04:30 -07003850int
Andy Adamsona1bcecd2009-04-03 08:28:05 +03003851nfs4_has_reclaimed_state(const char *name, bool use_exchange_id)
NeilBrownc7b9a452005-06-23 22:04:30 -07003852{
3853 unsigned int strhashval = clientstr_hashval(name);
3854 struct nfs4_client *clp;
3855
Andy Adamsona1bcecd2009-04-03 08:28:05 +03003856 clp = find_confirmed_client_by_str(name, strhashval, use_exchange_id);
NeilBrownc7b9a452005-06-23 22:04:30 -07003857 return clp ? 1 : 0;
3858}
3859
Linus Torvalds1da177e2005-04-16 15:20:36 -07003860/*
3861 * failure => all reset bets are off, nfserr_no_grace...
3862 */
NeilBrown190e4fb2005-06-23 22:04:25 -07003863int
3864nfs4_client_to_reclaim(const char *name)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003865{
3866 unsigned int strhashval;
3867 struct nfs4_client_reclaim *crp = NULL;
3868
NeilBrowna55370a2005-06-23 22:03:52 -07003869 dprintk("NFSD nfs4_client_to_reclaim NAME: %.*s\n", HEXDIR_LEN, name);
3870 crp = alloc_reclaim();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003871 if (!crp)
3872 return 0;
NeilBrowna55370a2005-06-23 22:03:52 -07003873 strhashval = clientstr_hashval(name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003874 INIT_LIST_HEAD(&crp->cr_strhash);
3875 list_add(&crp->cr_strhash, &reclaim_str_hashtbl[strhashval]);
NeilBrowna55370a2005-06-23 22:03:52 -07003876 memcpy(crp->cr_recdir, name, HEXDIR_LEN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003877 reclaim_str_hashtbl_size++;
3878 return 1;
3879}
3880
3881static void
3882nfs4_release_reclaim(void)
3883{
3884 struct nfs4_client_reclaim *crp = NULL;
3885 int i;
3886
Linus Torvalds1da177e2005-04-16 15:20:36 -07003887 for (i = 0; i < CLIENT_HASH_SIZE; i++) {
3888 while (!list_empty(&reclaim_str_hashtbl[i])) {
3889 crp = list_entry(reclaim_str_hashtbl[i].next,
3890 struct nfs4_client_reclaim, cr_strhash);
3891 list_del(&crp->cr_strhash);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003892 kfree(crp);
3893 reclaim_str_hashtbl_size--;
3894 }
3895 }
3896 BUG_ON(reclaim_str_hashtbl_size);
3897}
3898
3899/*
3900 * called from OPEN, CLAIM_PREVIOUS with a new clientid. */
NeilBrownfd39ca92005-06-23 22:04:03 -07003901static struct nfs4_client_reclaim *
Linus Torvalds1da177e2005-04-16 15:20:36 -07003902nfs4_find_reclaim_client(clientid_t *clid)
3903{
3904 unsigned int strhashval;
3905 struct nfs4_client *clp;
3906 struct nfs4_client_reclaim *crp = NULL;
3907
3908
3909 /* find clientid in conf_id_hashtbl */
3910 clp = find_confirmed_client(clid);
3911 if (clp == NULL)
3912 return NULL;
3913
NeilBrowna55370a2005-06-23 22:03:52 -07003914 dprintk("NFSD: nfs4_find_reclaim_client for %.*s with recdir %s\n",
3915 clp->cl_name.len, clp->cl_name.data,
3916 clp->cl_recdir);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003917
3918 /* find clp->cl_name in reclaim_str_hashtbl */
NeilBrowna55370a2005-06-23 22:03:52 -07003919 strhashval = clientstr_hashval(clp->cl_recdir);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003920 list_for_each_entry(crp, &reclaim_str_hashtbl[strhashval], cr_strhash) {
NeilBrowna55370a2005-06-23 22:03:52 -07003921 if (same_name(crp->cr_recdir, clp->cl_recdir)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003922 return crp;
3923 }
3924 }
3925 return NULL;
3926}
3927
3928/*
3929* Called from OPEN. Look for clientid in reclaim list.
3930*/
Al Virob37ad282006-10-19 23:28:59 -07003931__be32
Linus Torvalds1da177e2005-04-16 15:20:36 -07003932nfs4_check_open_reclaim(clientid_t *clid)
3933{
NeilBrowndfc83562005-06-23 22:03:16 -07003934 return nfs4_find_reclaim_client(clid) ? nfs_ok : nfserr_reclaim_bad;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003935}
3936
NeilBrownac4d8ff2005-06-23 22:03:30 -07003937/* initialization to perform at module load time: */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003938
J. Bruce Fieldse8ff2a82007-08-01 15:30:59 -04003939int
NeilBrownac4d8ff2005-06-23 22:03:30 -07003940nfs4_state_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003941{
J. Bruce Fieldse8ff2a82007-08-01 15:30:59 -04003942 int i, status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003943
J. Bruce Fieldse8ff2a82007-08-01 15:30:59 -04003944 status = nfsd4_init_slabs();
3945 if (status)
3946 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003947 for (i = 0; i < CLIENT_HASH_SIZE; i++) {
3948 INIT_LIST_HEAD(&conf_id_hashtbl[i]);
3949 INIT_LIST_HEAD(&conf_str_hashtbl[i]);
3950 INIT_LIST_HEAD(&unconf_str_hashtbl[i]);
3951 INIT_LIST_HEAD(&unconf_id_hashtbl[i]);
Wang Chen02cb2852009-04-24 15:41:57 +08003952 INIT_LIST_HEAD(&reclaim_str_hashtbl[i]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003953 }
Marc Eshel5282fd72009-04-03 08:27:52 +03003954 for (i = 0; i < SESSION_HASH_SIZE; i++)
3955 INIT_LIST_HEAD(&sessionid_hashtbl[i]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003956 for (i = 0; i < FILE_HASH_SIZE; i++) {
3957 INIT_LIST_HEAD(&file_hashtbl[i]);
3958 }
3959 for (i = 0; i < OWNER_HASH_SIZE; i++) {
3960 INIT_LIST_HEAD(&ownerstr_hashtbl[i]);
3961 INIT_LIST_HEAD(&ownerid_hashtbl[i]);
3962 }
3963 for (i = 0; i < STATEID_HASH_SIZE; i++) {
3964 INIT_LIST_HEAD(&stateid_hashtbl[i]);
3965 INIT_LIST_HEAD(&lockstateid_hashtbl[i]);
3966 }
3967 for (i = 0; i < LOCK_HASH_SIZE; i++) {
3968 INIT_LIST_HEAD(&lock_ownerid_hashtbl[i]);
3969 INIT_LIST_HEAD(&lock_ownerstr_hashtbl[i]);
3970 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003971 memset(&onestateid, ~0, sizeof(stateid_t));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003972 INIT_LIST_HEAD(&close_lru);
3973 INIT_LIST_HEAD(&client_lru);
3974 INIT_LIST_HEAD(&del_recall_lru);
NeilBrownac4d8ff2005-06-23 22:03:30 -07003975 reclaim_str_hashtbl_size = 0;
J. Bruce Fieldse8ff2a82007-08-01 15:30:59 -04003976 return 0;
NeilBrownac4d8ff2005-06-23 22:03:30 -07003977}
3978
NeilBrown190e4fb2005-06-23 22:04:25 -07003979static void
3980nfsd4_load_reboot_recovery_data(void)
3981{
3982 int status;
3983
NeilBrown0964a3d2005-06-23 22:04:32 -07003984 nfs4_lock_state();
3985 nfsd4_init_recdir(user_recovery_dirname);
NeilBrown190e4fb2005-06-23 22:04:25 -07003986 status = nfsd4_recdir_load();
NeilBrown0964a3d2005-06-23 22:04:32 -07003987 nfs4_unlock_state();
NeilBrown190e4fb2005-06-23 22:04:25 -07003988 if (status)
3989 printk("NFSD: Failure reading reboot recovery data\n");
3990}
3991
Marc Eshel9a8db972007-07-17 04:04:35 -07003992unsigned long
3993get_nfs4_grace_period(void)
3994{
3995 return max(user_lease_time, lease_time) * HZ;
3996}
3997
Meelap Shahc2f1a552007-07-17 04:04:39 -07003998/*
3999 * Since the lifetime of a delegation isn't limited to that of an open, a
4000 * client may quite reasonably hang on to a delegation as long as it has
4001 * the inode cached. This becomes an obvious problem the first time a
4002 * client's inode cache approaches the size of the server's total memory.
4003 *
4004 * For now we avoid this problem by imposing a hard limit on the number
4005 * of delegations, which varies according to the server's memory size.
4006 */
4007static void
4008set_max_delegations(void)
4009{
4010 /*
4011 * Allow at most 4 delegations per megabyte of RAM. Quick
4012 * estimates suggest that in the worst case (where every delegation
4013 * is for a different inode), a delegation could take about 1.5K,
4014 * giving a worst case usage of about 6% of memory.
4015 */
4016 max_delegations = nr_free_buffer_pages() >> (20 - 2 - PAGE_SHIFT);
4017}
4018
NeilBrownac4d8ff2005-06-23 22:03:30 -07004019/* initialization to perform when the nfsd service is started: */
4020
J. Bruce Fields29ab23c2009-09-15 15:56:50 -04004021static int
NeilBrownac4d8ff2005-06-23 22:03:30 -07004022__nfs4_state_start(void)
4023{
Marc Eshel9a8db972007-07-17 04:04:35 -07004024 unsigned long grace_time;
NeilBrownac4d8ff2005-06-23 22:03:30 -07004025
Linus Torvalds1da177e2005-04-16 15:20:36 -07004026 boot_time = get_seconds();
J. Bruce Fieldsaf558e32007-09-06 12:34:25 -04004027 grace_time = get_nfs4_grace_period();
NeilBrownd99a05a2005-06-23 22:03:21 -07004028 lease_time = user_lease_time;
J. Bruce Fieldsaf558e32007-09-06 12:34:25 -04004029 locks_start_grace(&nfsd4_manager);
Marc Eshel9a8db972007-07-17 04:04:35 -07004030 printk(KERN_INFO "NFSD: starting %ld-second grace period\n",
4031 grace_time/HZ);
NeilBrown58da2822005-06-23 22:03:19 -07004032 laundry_wq = create_singlethread_workqueue("nfsd4");
J. Bruce Fields29ab23c2009-09-15 15:56:50 -04004033 if (laundry_wq == NULL)
4034 return -ENOMEM;
Marc Eshel9a8db972007-07-17 04:04:35 -07004035 queue_delayed_work(laundry_wq, &laundromat_work, grace_time);
Meelap Shahc2f1a552007-07-17 04:04:39 -07004036 set_max_delegations();
J. Bruce Fields80fc0152009-09-15 18:07:35 -04004037 return set_callback_cred();
Linus Torvalds1da177e2005-04-16 15:20:36 -07004038}
4039
J. Bruce Fields29ab23c2009-09-15 15:56:50 -04004040int
NeilBrown76a35502005-06-23 22:03:26 -07004041nfs4_state_start(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004042{
J. Bruce Fields29ab23c2009-09-15 15:56:50 -04004043 int ret;
4044
Linus Torvalds1da177e2005-04-16 15:20:36 -07004045 if (nfs4_init)
J. Bruce Fields29ab23c2009-09-15 15:56:50 -04004046 return 0;
NeilBrown190e4fb2005-06-23 22:04:25 -07004047 nfsd4_load_reboot_recovery_data();
J. Bruce Fields29ab23c2009-09-15 15:56:50 -04004048 ret = __nfs4_state_start();
4049 if (ret)
4050 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004051 nfs4_init = 1;
J. Bruce Fields29ab23c2009-09-15 15:56:50 -04004052 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004053}
4054
Linus Torvalds1da177e2005-04-16 15:20:36 -07004055time_t
4056nfs4_lease_time(void)
4057{
4058 return lease_time;
4059}
4060
4061static void
4062__nfs4_state_shutdown(void)
4063{
4064 int i;
4065 struct nfs4_client *clp = NULL;
4066 struct nfs4_delegation *dp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004067 struct list_head *pos, *next, reaplist;
4068
Linus Torvalds1da177e2005-04-16 15:20:36 -07004069 for (i = 0; i < CLIENT_HASH_SIZE; i++) {
4070 while (!list_empty(&conf_id_hashtbl[i])) {
4071 clp = list_entry(conf_id_hashtbl[i].next, struct nfs4_client, cl_idhash);
4072 expire_client(clp);
4073 }
4074 while (!list_empty(&unconf_str_hashtbl[i])) {
4075 clp = list_entry(unconf_str_hashtbl[i].next, struct nfs4_client, cl_strhash);
4076 expire_client(clp);
4077 }
4078 }
4079 INIT_LIST_HEAD(&reaplist);
4080 spin_lock(&recall_lock);
4081 list_for_each_safe(pos, next, &del_recall_lru) {
4082 dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
4083 list_move(&dp->dl_recall_lru, &reaplist);
4084 }
4085 spin_unlock(&recall_lock);
4086 list_for_each_safe(pos, next, &reaplist) {
4087 dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
4088 list_del_init(&dp->dl_recall_lru);
4089 unhash_delegation(dp);
4090 }
4091
NeilBrown190e4fb2005-06-23 22:04:25 -07004092 nfsd4_shutdown_recdir();
Linus Torvalds1da177e2005-04-16 15:20:36 -07004093 nfs4_init = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004094}
4095
4096void
4097nfs4_state_shutdown(void)
4098{
NeilBrown5e8d5c22006-04-10 22:55:37 -07004099 cancel_rearming_delayed_workqueue(laundry_wq, &laundromat_work);
4100 destroy_workqueue(laundry_wq);
J. Bruce Fields2c5e7612008-11-20 14:36:17 -06004101 locks_end_grace(&nfsd4_manager);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004102 nfs4_lock_state();
4103 nfs4_release_reclaim();
4104 __nfs4_state_shutdown();
Linus Torvalds1da177e2005-04-16 15:20:36 -07004105 nfs4_unlock_state();
4106}
4107
Jeff Layton3dd98a32008-06-10 08:40:36 -04004108/*
4109 * user_recovery_dirname is protected by the nfsd_mutex since it's only
4110 * accessed when nfsd is starting.
4111 */
NeilBrown0964a3d2005-06-23 22:04:32 -07004112static void
4113nfs4_set_recdir(char *recdir)
4114{
NeilBrown0964a3d2005-06-23 22:04:32 -07004115 strcpy(user_recovery_dirname, recdir);
NeilBrown0964a3d2005-06-23 22:04:32 -07004116}
4117
4118/*
4119 * Change the NFSv4 recovery directory to recdir.
4120 */
4121int
4122nfs4_reset_recoverydir(char *recdir)
4123{
4124 int status;
Al Viroa63bb992008-08-02 01:03:36 -04004125 struct path path;
NeilBrown0964a3d2005-06-23 22:04:32 -07004126
Al Viroa63bb992008-08-02 01:03:36 -04004127 status = kern_path(recdir, LOOKUP_FOLLOW, &path);
NeilBrown0964a3d2005-06-23 22:04:32 -07004128 if (status)
4129 return status;
4130 status = -ENOTDIR;
Al Viroa63bb992008-08-02 01:03:36 -04004131 if (S_ISDIR(path.dentry->d_inode->i_mode)) {
NeilBrown0964a3d2005-06-23 22:04:32 -07004132 nfs4_set_recdir(recdir);
4133 status = 0;
4134 }
Al Viroa63bb992008-08-02 01:03:36 -04004135 path_put(&path);
NeilBrown0964a3d2005-06-23 22:04:32 -07004136 return status;
4137}
4138
Jeff Layton3dd98a32008-06-10 08:40:36 -04004139char *
4140nfs4_recoverydir(void)
4141{
4142 return user_recovery_dirname;
4143}
4144
Linus Torvalds1da177e2005-04-16 15:20:36 -07004145/*
4146 * Called when leasetime is changed.
4147 *
NeilBrownd99a05a2005-06-23 22:03:21 -07004148 * The only way the protocol gives us to handle on-the-fly lease changes is to
4149 * simulate a reboot. Instead of doing that, we just wait till the next time
4150 * we start to register any changes in lease time. If the administrator
4151 * really wants to change the lease time *now*, they can go ahead and bring
4152 * nfsd down and then back up again after changing the lease time.
Jeff Layton3dd98a32008-06-10 08:40:36 -04004153 *
4154 * user_lease_time is protected by nfsd_mutex since it's only really accessed
4155 * when nfsd is starting
Linus Torvalds1da177e2005-04-16 15:20:36 -07004156 */
4157void
4158nfs4_reset_lease(time_t leasetime)
4159{
NeilBrownd99a05a2005-06-23 22:03:21 -07004160 user_lease_time = leasetime;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004161}