2 * Copyright (c) 2001 The Regents of the University of Michigan.
5 * Kendrick Smith <kmsmith@umich.edu>
6 * Andy Adamson <kandros@umich.edu>
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
12 * 1. Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
14 * 2. Redistributions in binary form must reproduce the above copyright
15 * notice, this list of conditions and the following disclaimer in the
16 * documentation and/or other materials provided with the distribution.
17 * 3. Neither the name of the University nor the names of its
18 * contributors may be used to endorse or promote products derived
19 * from this software without specific prior written permission.
21 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
22 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
23 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
24 * DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
28 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
29 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
30 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
31 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
35 #include <linux/file.h>
36 #include <linux/smp_lock.h>
37 #include <linux/namei.h>
38 #include <linux/swap.h>
39 #include <linux/sunrpc/svcauth_gss.h>
40 #include <linux/sunrpc/clnt.h>
44 #define NFSDDBG_FACILITY NFSDDBG_PROC
47 time_t nfsd4_lease
= 90; /* default lease time */
48 time_t nfsd4_grace
= 90;
49 static time_t boot_time
;
50 static u32 current_ownerid
= 1;
51 static u32 current_fileid
= 1;
52 static u32 current_delegid
= 1;
54 static stateid_t zerostateid
; /* bits all 0 */
55 static stateid_t onestateid
; /* bits all 1 */
56 static u64 current_sessionid
= 1;
58 #define ZERO_STATEID(stateid) (!memcmp((stateid), &zerostateid, sizeof(stateid_t)))
59 #define ONE_STATEID(stateid) (!memcmp((stateid), &onestateid, sizeof(stateid_t)))
61 /* forward declarations */
62 static struct nfs4_stateid
* find_stateid(stateid_t
*stid
, int flags
);
63 static struct nfs4_delegation
* find_delegation_stateid(struct inode
*ino
, stateid_t
*stid
);
64 static char user_recovery_dirname
[PATH_MAX
] = "/var/lib/nfs/v4recovery";
65 static void nfs4_set_recdir(char *recdir
);
69 /* Currently used for almost all code touching nfsv4 state: */
70 static DEFINE_MUTEX(client_mutex
);
73 * Currently used for the del_recall_lru and file hash table. In an
74 * effort to decrease the scope of the client_mutex, this spinlock may
75 * eventually cover more:
77 static DEFINE_SPINLOCK(recall_lock
);
79 static struct kmem_cache
*stateowner_slab
= NULL
;
80 static struct kmem_cache
*file_slab
= NULL
;
81 static struct kmem_cache
*stateid_slab
= NULL
;
82 static struct kmem_cache
*deleg_slab
= NULL
;
87 mutex_lock(&client_mutex
);
91 nfs4_unlock_state(void)
93 mutex_unlock(&client_mutex
);
97 opaque_hashval(const void *ptr
, int nbytes
)
99 unsigned char *cptr
= (unsigned char *) ptr
;
109 static struct list_head del_recall_lru
;
112 put_nfs4_file(struct nfs4_file
*fi
)
114 if (atomic_dec_and_lock(&fi
->fi_ref
, &recall_lock
)) {
115 list_del(&fi
->fi_hash
);
116 spin_unlock(&recall_lock
);
118 kmem_cache_free(file_slab
, fi
);
123 get_nfs4_file(struct nfs4_file
*fi
)
125 atomic_inc(&fi
->fi_ref
);
128 static int num_delegations
;
129 unsigned int max_delegations
;
132 * Open owner state (share locks)
135 /* hash tables for nfs4_stateowner */
136 #define OWNER_HASH_BITS 8
137 #define OWNER_HASH_SIZE (1 << OWNER_HASH_BITS)
138 #define OWNER_HASH_MASK (OWNER_HASH_SIZE - 1)
140 #define ownerid_hashval(id) \
141 ((id) & OWNER_HASH_MASK)
142 #define ownerstr_hashval(clientid, ownername) \
143 (((clientid) + opaque_hashval((ownername.data), (ownername.len))) & OWNER_HASH_MASK)
145 static struct list_head ownerid_hashtbl
[OWNER_HASH_SIZE
];
146 static struct list_head ownerstr_hashtbl
[OWNER_HASH_SIZE
];
148 /* hash table for nfs4_file */
149 #define FILE_HASH_BITS 8
150 #define FILE_HASH_SIZE (1 << FILE_HASH_BITS)
151 #define FILE_HASH_MASK (FILE_HASH_SIZE - 1)
152 /* hash table for (open)nfs4_stateid */
153 #define STATEID_HASH_BITS 10
154 #define STATEID_HASH_SIZE (1 << STATEID_HASH_BITS)
155 #define STATEID_HASH_MASK (STATEID_HASH_SIZE - 1)
157 #define file_hashval(x) \
158 hash_ptr(x, FILE_HASH_BITS)
159 #define stateid_hashval(owner_id, file_id) \
160 (((owner_id) + (file_id)) & STATEID_HASH_MASK)
162 static struct list_head file_hashtbl
[FILE_HASH_SIZE
];
163 static struct list_head stateid_hashtbl
[STATEID_HASH_SIZE
];
165 static struct nfs4_delegation
*
166 alloc_init_deleg(struct nfs4_client
*clp
, struct nfs4_stateid
*stp
, struct svc_fh
*current_fh
, u32 type
)
168 struct nfs4_delegation
*dp
;
169 struct nfs4_file
*fp
= stp
->st_file
;
170 struct nfs4_cb_conn
*cb
= &stp
->st_stateowner
->so_client
->cl_cb_conn
;
172 dprintk("NFSD alloc_init_deleg\n");
173 if (fp
->fi_had_conflict
)
175 if (num_delegations
> max_delegations
)
177 dp
= kmem_cache_alloc(deleg_slab
, GFP_KERNEL
);
181 INIT_LIST_HEAD(&dp
->dl_perfile
);
182 INIT_LIST_HEAD(&dp
->dl_perclnt
);
183 INIT_LIST_HEAD(&dp
->dl_recall_lru
);
188 get_file(stp
->st_vfs_file
);
189 dp
->dl_vfs_file
= stp
->st_vfs_file
;
191 dp
->dl_ident
= cb
->cb_ident
;
192 dp
->dl_stateid
.si_boot
= get_seconds();
193 dp
->dl_stateid
.si_stateownerid
= current_delegid
++;
194 dp
->dl_stateid
.si_fileid
= 0;
195 dp
->dl_stateid
.si_generation
= 0;
196 fh_copy_shallow(&dp
->dl_fh
, ¤t_fh
->fh_handle
);
198 atomic_set(&dp
->dl_count
, 1);
199 list_add(&dp
->dl_perfile
, &fp
->fi_delegations
);
200 list_add(&dp
->dl_perclnt
, &clp
->cl_delegations
);
205 nfs4_put_delegation(struct nfs4_delegation
*dp
)
207 if (atomic_dec_and_test(&dp
->dl_count
)) {
208 dprintk("NFSD: freeing dp %p\n",dp
);
209 put_nfs4_file(dp
->dl_file
);
210 kmem_cache_free(deleg_slab
, dp
);
215 /* Remove the associated file_lock first, then remove the delegation.
216 * lease_modify() is called to remove the FS_LEASE file_lock from
217 * the i_flock list, eventually calling nfsd's lock_manager
218 * fl_release_callback.
221 nfs4_close_delegation(struct nfs4_delegation
*dp
)
223 struct file
*filp
= dp
->dl_vfs_file
;
225 dprintk("NFSD: close_delegation dp %p\n",dp
);
226 dp
->dl_vfs_file
= NULL
;
227 /* The following nfsd_close may not actually close the file,
228 * but we want to remove the lease in any case. */
230 vfs_setlease(filp
, F_UNLCK
, &dp
->dl_flock
);
234 /* Called under the state lock. */
236 unhash_delegation(struct nfs4_delegation
*dp
)
238 list_del_init(&dp
->dl_perfile
);
239 list_del_init(&dp
->dl_perclnt
);
240 spin_lock(&recall_lock
);
241 list_del_init(&dp
->dl_recall_lru
);
242 spin_unlock(&recall_lock
);
243 nfs4_close_delegation(dp
);
244 nfs4_put_delegation(dp
);
251 /* Hash tables for nfs4_clientid state */
252 #define CLIENT_HASH_BITS 4
253 #define CLIENT_HASH_SIZE (1 << CLIENT_HASH_BITS)
254 #define CLIENT_HASH_MASK (CLIENT_HASH_SIZE - 1)
256 #define clientid_hashval(id) \
257 ((id) & CLIENT_HASH_MASK)
258 #define clientstr_hashval(name) \
259 (opaque_hashval((name), 8) & CLIENT_HASH_MASK)
261 * reclaim_str_hashtbl[] holds known client info from previous reset/reboot
262 * used in reboot/reset lease grace period processing
264 * conf_id_hashtbl[], and conf_str_hashtbl[] hold confirmed
265 * setclientid_confirmed info.
267 * unconf_str_hastbl[] and unconf_id_hashtbl[] hold unconfirmed
270 * client_lru holds client queue ordered by nfs4_client.cl_time
273 * close_lru holds (open) stateowner queue ordered by nfs4_stateowner.so_time
274 * for last close replay.
276 static struct list_head reclaim_str_hashtbl
[CLIENT_HASH_SIZE
];
277 static int reclaim_str_hashtbl_size
= 0;
278 static struct list_head conf_id_hashtbl
[CLIENT_HASH_SIZE
];
279 static struct list_head conf_str_hashtbl
[CLIENT_HASH_SIZE
];
280 static struct list_head unconf_str_hashtbl
[CLIENT_HASH_SIZE
];
281 static struct list_head unconf_id_hashtbl
[CLIENT_HASH_SIZE
];
282 static struct list_head client_lru
;
283 static struct list_head close_lru
;
285 static void unhash_generic_stateid(struct nfs4_stateid
*stp
)
287 list_del(&stp
->st_hash
);
288 list_del(&stp
->st_perfile
);
289 list_del(&stp
->st_perstateowner
);
292 static void free_generic_stateid(struct nfs4_stateid
*stp
)
294 put_nfs4_file(stp
->st_file
);
295 kmem_cache_free(stateid_slab
, stp
);
298 static void release_lock_stateid(struct nfs4_stateid
*stp
)
300 unhash_generic_stateid(stp
);
301 locks_remove_posix(stp
->st_vfs_file
, (fl_owner_t
)stp
->st_stateowner
);
302 free_generic_stateid(stp
);
305 static void unhash_lockowner(struct nfs4_stateowner
*sop
)
307 struct nfs4_stateid
*stp
;
309 list_del(&sop
->so_idhash
);
310 list_del(&sop
->so_strhash
);
311 list_del(&sop
->so_perstateid
);
312 while (!list_empty(&sop
->so_stateids
)) {
313 stp
= list_first_entry(&sop
->so_stateids
,
314 struct nfs4_stateid
, st_perstateowner
);
315 release_lock_stateid(stp
);
319 static void release_lockowner(struct nfs4_stateowner
*sop
)
321 unhash_lockowner(sop
);
322 nfs4_put_stateowner(sop
);
326 release_stateid_lockowners(struct nfs4_stateid
*open_stp
)
328 struct nfs4_stateowner
*lock_sop
;
330 while (!list_empty(&open_stp
->st_lockowners
)) {
331 lock_sop
= list_entry(open_stp
->st_lockowners
.next
,
332 struct nfs4_stateowner
, so_perstateid
);
333 /* list_del(&open_stp->st_lockowners); */
334 BUG_ON(lock_sop
->so_is_open_owner
);
335 release_lockowner(lock_sop
);
339 static void release_open_stateid(struct nfs4_stateid
*stp
)
341 unhash_generic_stateid(stp
);
342 release_stateid_lockowners(stp
);
343 nfsd_close(stp
->st_vfs_file
);
344 free_generic_stateid(stp
);
347 static void unhash_openowner(struct nfs4_stateowner
*sop
)
349 struct nfs4_stateid
*stp
;
351 list_del(&sop
->so_idhash
);
352 list_del(&sop
->so_strhash
);
353 list_del(&sop
->so_perclient
);
354 list_del(&sop
->so_perstateid
); /* XXX: necessary? */
355 while (!list_empty(&sop
->so_stateids
)) {
356 stp
= list_first_entry(&sop
->so_stateids
,
357 struct nfs4_stateid
, st_perstateowner
);
358 release_open_stateid(stp
);
362 static void release_openowner(struct nfs4_stateowner
*sop
)
364 unhash_openowner(sop
);
365 list_del(&sop
->so_close_lru
);
366 nfs4_put_stateowner(sop
);
369 static DEFINE_SPINLOCK(sessionid_lock
);
370 #define SESSION_HASH_SIZE 512
371 static struct list_head sessionid_hashtbl
[SESSION_HASH_SIZE
];
374 hash_sessionid(struct nfs4_sessionid
*sessionid
)
376 struct nfsd4_sessionid
*sid
= (struct nfsd4_sessionid
*)sessionid
;
378 return sid
->sequence
% SESSION_HASH_SIZE
;
382 dump_sessionid(const char *fn
, struct nfs4_sessionid
*sessionid
)
384 u32
*ptr
= (u32
*)(&sessionid
->data
[0]);
385 dprintk("%s: %u:%u:%u:%u\n", fn
, ptr
[0], ptr
[1], ptr
[2], ptr
[3]);
389 gen_sessionid(struct nfsd4_session
*ses
)
391 struct nfs4_client
*clp
= ses
->se_client
;
392 struct nfsd4_sessionid
*sid
;
394 sid
= (struct nfsd4_sessionid
*)ses
->se_sessionid
.data
;
395 sid
->clientid
= clp
->cl_clientid
;
396 sid
->sequence
= current_sessionid
++;
401 * The protocol defines ca_maxresponssize_cached to include the size of
402 * the rpc header, but all we need to cache is the data starting after
403 * the end of the initial SEQUENCE operation--the rest we regenerate
404 * each time. Therefore we can advertise a ca_maxresponssize_cached
405 * value that is the number of bytes in our cache plus a few additional
406 * bytes. In order to stay on the safe side, and not promise more than
407 * we can cache, those additional bytes must be the minimum possible: 24
408 * bytes of rpc header (xid through accept state, with AUTH_NULL
409 * verifier), 12 for the compound header (with zero-length tag), and 44
410 * for the SEQUENCE op response:
412 #define NFSD_MIN_HDR_SEQ_SZ (24 + 12 + 44)
415 * Give the client the number of ca_maxresponsesize_cached slots it
416 * requests, of size bounded by NFSD_SLOT_CACHE_SIZE,
417 * NFSD_MAX_MEM_PER_SESSION, and nfsd_drc_max_mem. Do not allow more
418 * than NFSD_MAX_SLOTS_PER_SESSION.
420 * If we run out of reserved DRC memory we should (up to a point)
421 * re-negotiate active sessions and reduce their slot usage to make
422 * rooom for new connections. For now we just fail the create session.
424 static int set_forechannel_drc_size(struct nfsd4_channel_attrs
*fchan
)
426 int mem
, size
= fchan
->maxresp_cached
;
428 if (fchan
->maxreqs
< 1)
431 if (size
< NFSD_MIN_HDR_SEQ_SZ
)
432 size
= NFSD_MIN_HDR_SEQ_SZ
;
433 size
-= NFSD_MIN_HDR_SEQ_SZ
;
434 if (size
> NFSD_SLOT_CACHE_SIZE
)
435 size
= NFSD_SLOT_CACHE_SIZE
;
437 /* bound the maxreqs by NFSD_MAX_MEM_PER_SESSION */
438 mem
= fchan
->maxreqs
* size
;
439 if (mem
> NFSD_MAX_MEM_PER_SESSION
) {
440 fchan
->maxreqs
= NFSD_MAX_MEM_PER_SESSION
/ size
;
441 if (fchan
->maxreqs
> NFSD_MAX_SLOTS_PER_SESSION
)
442 fchan
->maxreqs
= NFSD_MAX_SLOTS_PER_SESSION
;
443 mem
= fchan
->maxreqs
* size
;
446 spin_lock(&nfsd_drc_lock
);
447 /* bound the total session drc memory ussage */
448 if (mem
+ nfsd_drc_mem_used
> nfsd_drc_max_mem
) {
449 fchan
->maxreqs
= (nfsd_drc_max_mem
- nfsd_drc_mem_used
) / size
;
450 mem
= fchan
->maxreqs
* size
;
452 nfsd_drc_mem_used
+= mem
;
453 spin_unlock(&nfsd_drc_lock
);
455 if (fchan
->maxreqs
== 0)
456 return nfserr_serverfault
;
458 fchan
->maxresp_cached
= size
+ NFSD_MIN_HDR_SEQ_SZ
;
463 * fchan holds the client values on input, and the server values on output
464 * sv_max_mesg is the maximum payload plus one page for overhead.
466 static int init_forechannel_attrs(struct svc_rqst
*rqstp
,
467 struct nfsd4_channel_attrs
*session_fchan
,
468 struct nfsd4_channel_attrs
*fchan
)
471 __u32 maxcount
= nfsd_serv
->sv_max_mesg
;
473 /* headerpadsz set to zero in encode routine */
475 /* Use the client's max request and max response size if possible */
476 if (fchan
->maxreq_sz
> maxcount
)
477 fchan
->maxreq_sz
= maxcount
;
478 session_fchan
->maxreq_sz
= fchan
->maxreq_sz
;
480 if (fchan
->maxresp_sz
> maxcount
)
481 fchan
->maxresp_sz
= maxcount
;
482 session_fchan
->maxresp_sz
= fchan
->maxresp_sz
;
484 /* Use the client's maxops if possible */
485 if (fchan
->maxops
> NFSD_MAX_OPS_PER_COMPOUND
)
486 fchan
->maxops
= NFSD_MAX_OPS_PER_COMPOUND
;
487 session_fchan
->maxops
= fchan
->maxops
;
489 /* FIXME: Error means no more DRC pages so the server should
490 * recover pages from existing sessions. For now fail session
493 status
= set_forechannel_drc_size(fchan
);
495 session_fchan
->maxresp_cached
= fchan
->maxresp_cached
;
496 session_fchan
->maxreqs
= fchan
->maxreqs
;
498 dprintk("%s status %d\n", __func__
, status
);
503 free_session_slots(struct nfsd4_session
*ses
)
507 for (i
= 0; i
< ses
->se_fchannel
.maxreqs
; i
++)
508 kfree(ses
->se_slots
[i
]);
512 * We don't actually need to cache the rpc and session headers, so we
513 * can allocate a little less for each slot:
515 static inline int slot_bytes(struct nfsd4_channel_attrs
*ca
)
517 return ca
->maxresp_cached
- NFSD_MIN_HDR_SEQ_SZ
;
521 alloc_init_session(struct svc_rqst
*rqstp
, struct nfs4_client
*clp
,
522 struct nfsd4_create_session
*cses
)
524 struct nfsd4_session
*new, tmp
;
525 struct nfsd4_slot
*sp
;
526 int idx
, slotsize
, cachesize
, i
;
529 memset(&tmp
, 0, sizeof(tmp
));
531 /* FIXME: For now, we just accept the client back channel attributes. */
532 tmp
.se_bchannel
= cses
->back_channel
;
533 status
= init_forechannel_attrs(rqstp
, &tmp
.se_fchannel
,
534 &cses
->fore_channel
);
538 BUILD_BUG_ON(NFSD_MAX_SLOTS_PER_SESSION
* sizeof(struct nfsd4_slot
)
539 + sizeof(struct nfsd4_session
) > PAGE_SIZE
);
541 status
= nfserr_serverfault
;
542 /* allocate struct nfsd4_session and slot table pointers in one piece */
543 slotsize
= tmp
.se_fchannel
.maxreqs
* sizeof(struct nfsd4_slot
*);
544 new = kzalloc(sizeof(*new) + slotsize
, GFP_KERNEL
);
548 memcpy(new, &tmp
, sizeof(*new));
550 /* allocate each struct nfsd4_slot and data cache in one piece */
551 cachesize
= slot_bytes(&new->se_fchannel
);
552 for (i
= 0; i
< new->se_fchannel
.maxreqs
; i
++) {
553 sp
= kzalloc(sizeof(*sp
) + cachesize
, GFP_KERNEL
);
556 new->se_slots
[i
] = sp
;
559 new->se_client
= clp
;
561 idx
= hash_sessionid(&new->se_sessionid
);
562 memcpy(clp
->cl_sessionid
.data
, new->se_sessionid
.data
,
563 NFS4_MAX_SESSIONID_LEN
);
565 new->se_flags
= cses
->flags
;
566 kref_init(&new->se_ref
);
567 spin_lock(&sessionid_lock
);
568 list_add(&new->se_hash
, &sessionid_hashtbl
[idx
]);
569 list_add(&new->se_perclnt
, &clp
->cl_sessions
);
570 spin_unlock(&sessionid_lock
);
576 free_session_slots(new);
581 /* caller must hold sessionid_lock */
582 static struct nfsd4_session
*
583 find_in_sessionid_hashtbl(struct nfs4_sessionid
*sessionid
)
585 struct nfsd4_session
*elem
;
588 dump_sessionid(__func__
, sessionid
);
589 idx
= hash_sessionid(sessionid
);
590 dprintk("%s: idx is %d\n", __func__
, idx
);
591 /* Search in the appropriate list */
592 list_for_each_entry(elem
, &sessionid_hashtbl
[idx
], se_hash
) {
593 dump_sessionid("list traversal", &elem
->se_sessionid
);
594 if (!memcmp(elem
->se_sessionid
.data
, sessionid
->data
,
595 NFS4_MAX_SESSIONID_LEN
)) {
600 dprintk("%s: session not found\n", __func__
);
604 /* caller must hold sessionid_lock */
606 unhash_session(struct nfsd4_session
*ses
)
608 list_del(&ses
->se_hash
);
609 list_del(&ses
->se_perclnt
);
613 release_session(struct nfsd4_session
*ses
)
615 spin_lock(&sessionid_lock
);
617 spin_unlock(&sessionid_lock
);
618 nfsd4_put_session(ses
);
622 free_session(struct kref
*kref
)
624 struct nfsd4_session
*ses
;
627 ses
= container_of(kref
, struct nfsd4_session
, se_ref
);
628 spin_lock(&nfsd_drc_lock
);
629 mem
= ses
->se_fchannel
.maxreqs
* slot_bytes(&ses
->se_fchannel
);
630 nfsd_drc_mem_used
-= mem
;
631 spin_unlock(&nfsd_drc_lock
);
632 free_session_slots(ses
);
637 renew_client(struct nfs4_client
*clp
)
640 * Move client to the end to the LRU list.
642 dprintk("renewing client (clientid %08x/%08x)\n",
643 clp
->cl_clientid
.cl_boot
,
644 clp
->cl_clientid
.cl_id
);
645 list_move_tail(&clp
->cl_lru
, &client_lru
);
646 clp
->cl_time
= get_seconds();
649 /* SETCLIENTID and SETCLIENTID_CONFIRM Helper functions */
651 STALE_CLIENTID(clientid_t
*clid
)
653 if (clid
->cl_boot
== boot_time
)
655 dprintk("NFSD stale clientid (%08x/%08x) boot_time %08lx\n",
656 clid
->cl_boot
, clid
->cl_id
, boot_time
);
661 * XXX Should we use a slab cache ?
662 * This type of memory management is somewhat inefficient, but we use it
663 * anyway since SETCLIENTID is not a common operation.
665 static struct nfs4_client
*alloc_client(struct xdr_netobj name
)
667 struct nfs4_client
*clp
;
669 clp
= kzalloc(sizeof(struct nfs4_client
), GFP_KERNEL
);
672 clp
->cl_name
.data
= kmalloc(name
.len
, GFP_KERNEL
);
673 if (clp
->cl_name
.data
== NULL
) {
677 memcpy(clp
->cl_name
.data
, name
.data
, name
.len
);
678 clp
->cl_name
.len
= name
.len
;
683 shutdown_callback_client(struct nfs4_client
*clp
)
685 struct rpc_clnt
*clnt
= clp
->cl_cb_conn
.cb_client
;
689 * Callback threads take a reference on the client, so there
690 * should be no outstanding callbacks at this point.
692 clp
->cl_cb_conn
.cb_client
= NULL
;
693 rpc_shutdown_client(clnt
);
698 free_client(struct nfs4_client
*clp
)
700 if (clp
->cl_cred
.cr_group_info
)
701 put_group_info(clp
->cl_cred
.cr_group_info
);
702 kfree(clp
->cl_principal
);
703 kfree(clp
->cl_name
.data
);
708 put_nfs4_client(struct nfs4_client
*clp
)
710 if (atomic_dec_and_test(&clp
->cl_count
))
715 expire_client(struct nfs4_client
*clp
)
717 struct nfs4_stateowner
*sop
;
718 struct nfs4_delegation
*dp
;
719 struct list_head reaplist
;
721 INIT_LIST_HEAD(&reaplist
);
722 spin_lock(&recall_lock
);
723 while (!list_empty(&clp
->cl_delegations
)) {
724 dp
= list_entry(clp
->cl_delegations
.next
, struct nfs4_delegation
, dl_perclnt
);
725 dprintk("NFSD: expire client. dp %p, fp %p\n", dp
,
727 list_del_init(&dp
->dl_perclnt
);
728 list_move(&dp
->dl_recall_lru
, &reaplist
);
730 spin_unlock(&recall_lock
);
731 while (!list_empty(&reaplist
)) {
732 dp
= list_entry(reaplist
.next
, struct nfs4_delegation
, dl_recall_lru
);
733 list_del_init(&dp
->dl_recall_lru
);
734 unhash_delegation(dp
);
736 list_del(&clp
->cl_idhash
);
737 list_del(&clp
->cl_strhash
);
738 list_del(&clp
->cl_lru
);
739 while (!list_empty(&clp
->cl_openowners
)) {
740 sop
= list_entry(clp
->cl_openowners
.next
, struct nfs4_stateowner
, so_perclient
);
741 release_openowner(sop
);
743 while (!list_empty(&clp
->cl_sessions
)) {
744 struct nfsd4_session
*ses
;
745 ses
= list_entry(clp
->cl_sessions
.next
, struct nfsd4_session
,
747 release_session(ses
);
749 shutdown_callback_client(clp
);
751 svc_xprt_put(clp
->cl_cb_xprt
);
752 put_nfs4_client(clp
);
755 static void copy_verf(struct nfs4_client
*target
, nfs4_verifier
*source
)
757 memcpy(target
->cl_verifier
.data
, source
->data
,
758 sizeof(target
->cl_verifier
.data
));
761 static void copy_clid(struct nfs4_client
*target
, struct nfs4_client
*source
)
763 target
->cl_clientid
.cl_boot
= source
->cl_clientid
.cl_boot
;
764 target
->cl_clientid
.cl_id
= source
->cl_clientid
.cl_id
;
767 static void copy_cred(struct svc_cred
*target
, struct svc_cred
*source
)
769 target
->cr_uid
= source
->cr_uid
;
770 target
->cr_gid
= source
->cr_gid
;
771 target
->cr_group_info
= source
->cr_group_info
;
772 get_group_info(target
->cr_group_info
);
775 static int same_name(const char *n1
, const char *n2
)
777 return 0 == memcmp(n1
, n2
, HEXDIR_LEN
);
781 same_verf(nfs4_verifier
*v1
, nfs4_verifier
*v2
)
783 return 0 == memcmp(v1
->data
, v2
->data
, sizeof(v1
->data
));
787 same_clid(clientid_t
*cl1
, clientid_t
*cl2
)
789 return (cl1
->cl_boot
== cl2
->cl_boot
) && (cl1
->cl_id
== cl2
->cl_id
);
792 /* XXX what about NGROUP */
794 same_creds(struct svc_cred
*cr1
, struct svc_cred
*cr2
)
796 return cr1
->cr_uid
== cr2
->cr_uid
;
799 static void gen_clid(struct nfs4_client
*clp
)
801 static u32 current_clientid
= 1;
803 clp
->cl_clientid
.cl_boot
= boot_time
;
804 clp
->cl_clientid
.cl_id
= current_clientid
++;
807 static void gen_confirm(struct nfs4_client
*clp
)
812 p
= (u32
*)clp
->cl_confirm
.data
;
813 *p
++ = get_seconds();
817 static struct nfs4_client
*create_client(struct xdr_netobj name
, char *recdir
,
818 struct svc_rqst
*rqstp
, nfs4_verifier
*verf
)
820 struct nfs4_client
*clp
;
821 struct sockaddr
*sa
= svc_addr(rqstp
);
824 clp
= alloc_client(name
);
828 princ
= svc_gss_principal(rqstp
);
830 clp
->cl_principal
= kstrdup(princ
, GFP_KERNEL
);
831 if (clp
->cl_principal
== NULL
) {
837 memcpy(clp
->cl_recdir
, recdir
, HEXDIR_LEN
);
838 atomic_set(&clp
->cl_count
, 1);
839 atomic_set(&clp
->cl_cb_conn
.cb_set
, 0);
840 INIT_LIST_HEAD(&clp
->cl_idhash
);
841 INIT_LIST_HEAD(&clp
->cl_strhash
);
842 INIT_LIST_HEAD(&clp
->cl_openowners
);
843 INIT_LIST_HEAD(&clp
->cl_delegations
);
844 INIT_LIST_HEAD(&clp
->cl_sessions
);
845 INIT_LIST_HEAD(&clp
->cl_lru
);
846 clear_bit(0, &clp
->cl_cb_slot_busy
);
847 rpc_init_wait_queue(&clp
->cl_cb_waitq
, "Backchannel slot table");
848 copy_verf(clp
, verf
);
849 rpc_copy_addr((struct sockaddr
*) &clp
->cl_addr
, sa
);
850 clp
->cl_flavor
= rqstp
->rq_flavor
;
851 copy_cred(&clp
->cl_cred
, &rqstp
->rq_cred
);
857 static int check_name(struct xdr_netobj name
)
861 if (name
.len
> NFS4_OPAQUE_LIMIT
) {
862 dprintk("NFSD: check_name: name too long(%d)!\n", name
.len
);
869 add_to_unconfirmed(struct nfs4_client
*clp
, unsigned int strhashval
)
871 unsigned int idhashval
;
873 list_add(&clp
->cl_strhash
, &unconf_str_hashtbl
[strhashval
]);
874 idhashval
= clientid_hashval(clp
->cl_clientid
.cl_id
);
875 list_add(&clp
->cl_idhash
, &unconf_id_hashtbl
[idhashval
]);
876 list_add_tail(&clp
->cl_lru
, &client_lru
);
877 clp
->cl_time
= get_seconds();
881 move_to_confirmed(struct nfs4_client
*clp
)
883 unsigned int idhashval
= clientid_hashval(clp
->cl_clientid
.cl_id
);
884 unsigned int strhashval
;
886 dprintk("NFSD: move_to_confirm nfs4_client %p\n", clp
);
887 list_del_init(&clp
->cl_strhash
);
888 list_move(&clp
->cl_idhash
, &conf_id_hashtbl
[idhashval
]);
889 strhashval
= clientstr_hashval(clp
->cl_recdir
);
890 list_add(&clp
->cl_strhash
, &conf_str_hashtbl
[strhashval
]);
894 static struct nfs4_client
*
895 find_confirmed_client(clientid_t
*clid
)
897 struct nfs4_client
*clp
;
898 unsigned int idhashval
= clientid_hashval(clid
->cl_id
);
900 list_for_each_entry(clp
, &conf_id_hashtbl
[idhashval
], cl_idhash
) {
901 if (same_clid(&clp
->cl_clientid
, clid
))
907 static struct nfs4_client
*
908 find_unconfirmed_client(clientid_t
*clid
)
910 struct nfs4_client
*clp
;
911 unsigned int idhashval
= clientid_hashval(clid
->cl_id
);
913 list_for_each_entry(clp
, &unconf_id_hashtbl
[idhashval
], cl_idhash
) {
914 if (same_clid(&clp
->cl_clientid
, clid
))
921 * Return 1 iff clp's clientid establishment method matches the use_exchange_id
922 * parameter. Matching is based on the fact the at least one of the
923 * EXCHGID4_FLAG_USE_{NON_PNFS,PNFS_MDS,PNFS_DS} flags must be set for v4.1
925 * FIXME: we need to unify the clientid namespaces for nfsv4.x
926 * and correctly deal with client upgrade/downgrade in EXCHANGE_ID
927 * and SET_CLIENTID{,_CONFIRM}
930 match_clientid_establishment(struct nfs4_client
*clp
, bool use_exchange_id
)
932 bool has_exchange_flags
= (clp
->cl_exchange_flags
!= 0);
933 return use_exchange_id
== has_exchange_flags
;
936 static struct nfs4_client
*
937 find_confirmed_client_by_str(const char *dname
, unsigned int hashval
,
938 bool use_exchange_id
)
940 struct nfs4_client
*clp
;
942 list_for_each_entry(clp
, &conf_str_hashtbl
[hashval
], cl_strhash
) {
943 if (same_name(clp
->cl_recdir
, dname
) &&
944 match_clientid_establishment(clp
, use_exchange_id
))
950 static struct nfs4_client
*
951 find_unconfirmed_client_by_str(const char *dname
, unsigned int hashval
,
952 bool use_exchange_id
)
954 struct nfs4_client
*clp
;
956 list_for_each_entry(clp
, &unconf_str_hashtbl
[hashval
], cl_strhash
) {
957 if (same_name(clp
->cl_recdir
, dname
) &&
958 match_clientid_establishment(clp
, use_exchange_id
))
965 gen_callback(struct nfs4_client
*clp
, struct nfsd4_setclientid
*se
, u32 scopeid
)
967 struct nfs4_cb_conn
*cb
= &clp
->cl_cb_conn
;
968 unsigned short expected_family
;
970 /* Currently, we only support tcp and tcp6 for the callback channel */
971 if (se
->se_callback_netid_len
== 3 &&
972 !memcmp(se
->se_callback_netid_val
, "tcp", 3))
973 expected_family
= AF_INET
;
974 else if (se
->se_callback_netid_len
== 4 &&
975 !memcmp(se
->se_callback_netid_val
, "tcp6", 4))
976 expected_family
= AF_INET6
;
980 cb
->cb_addrlen
= rpc_uaddr2sockaddr(se
->se_callback_addr_val
,
981 se
->se_callback_addr_len
,
982 (struct sockaddr
*) &cb
->cb_addr
,
983 sizeof(cb
->cb_addr
));
985 if (!cb
->cb_addrlen
|| cb
->cb_addr
.ss_family
!= expected_family
)
988 if (cb
->cb_addr
.ss_family
== AF_INET6
)
989 ((struct sockaddr_in6
*) &cb
->cb_addr
)->sin6_scope_id
= scopeid
;
991 cb
->cb_minorversion
= 0;
992 cb
->cb_prog
= se
->se_callback_prog
;
993 cb
->cb_ident
= se
->se_callback_ident
;
996 cb
->cb_addr
.ss_family
= AF_UNSPEC
;
998 dprintk(KERN_INFO
"NFSD: this client (clientid %08x/%08x) "
999 "will not receive delegations\n",
1000 clp
->cl_clientid
.cl_boot
, clp
->cl_clientid
.cl_id
);
1006 * Cache a reply. nfsd4_check_drc_limit() has bounded the cache size.
1009 nfsd4_store_cache_entry(struct nfsd4_compoundres
*resp
)
1011 struct nfsd4_slot
*slot
= resp
->cstate
.slot
;
1014 dprintk("--> %s slot %p\n", __func__
, slot
);
1016 slot
->sl_opcnt
= resp
->opcnt
;
1017 slot
->sl_status
= resp
->cstate
.status
;
1019 if (nfsd4_not_cached(resp
)) {
1020 slot
->sl_datalen
= 0;
1023 slot
->sl_datalen
= (char *)resp
->p
- (char *)resp
->cstate
.datap
;
1024 base
= (char *)resp
->cstate
.datap
-
1025 (char *)resp
->xbuf
->head
[0].iov_base
;
1026 if (read_bytes_from_xdr_buf(resp
->xbuf
, base
, slot
->sl_data
,
1028 WARN("%s: sessions DRC could not cache compound\n", __func__
);
1033 * Encode the replay sequence operation from the slot values.
1034 * If cachethis is FALSE encode the uncached rep error on the next
1035 * operation which sets resp->p and increments resp->opcnt for
1036 * nfs4svc_encode_compoundres.
1040 nfsd4_enc_sequence_replay(struct nfsd4_compoundargs
*args
,
1041 struct nfsd4_compoundres
*resp
)
1043 struct nfsd4_op
*op
;
1044 struct nfsd4_slot
*slot
= resp
->cstate
.slot
;
1046 dprintk("--> %s resp->opcnt %d cachethis %u \n", __func__
,
1047 resp
->opcnt
, resp
->cstate
.slot
->sl_cachethis
);
1049 /* Encode the replayed sequence operation */
1050 op
= &args
->ops
[resp
->opcnt
- 1];
1051 nfsd4_encode_operation(resp
, op
);
1053 /* Return nfserr_retry_uncached_rep in next operation. */
1054 if (args
->opcnt
> 1 && slot
->sl_cachethis
== 0) {
1055 op
= &args
->ops
[resp
->opcnt
++];
1056 op
->status
= nfserr_retry_uncached_rep
;
1057 nfsd4_encode_operation(resp
, op
);
1063 * The sequence operation is not cached because we can use the slot and
1067 nfsd4_replay_cache_entry(struct nfsd4_compoundres
*resp
,
1068 struct nfsd4_sequence
*seq
)
1070 struct nfsd4_slot
*slot
= resp
->cstate
.slot
;
1073 dprintk("--> %s slot %p\n", __func__
, slot
);
1075 /* Either returns 0 or nfserr_retry_uncached */
1076 status
= nfsd4_enc_sequence_replay(resp
->rqstp
->rq_argp
, resp
);
1077 if (status
== nfserr_retry_uncached_rep
)
1080 /* The sequence operation has been encoded, cstate->datap set. */
1081 memcpy(resp
->cstate
.datap
, slot
->sl_data
, slot
->sl_datalen
);
1083 resp
->opcnt
= slot
->sl_opcnt
;
1084 resp
->p
= resp
->cstate
.datap
+ XDR_QUADLEN(slot
->sl_datalen
);
1085 status
= slot
->sl_status
;
1091 * Set the exchange_id flags returned by the server.
1094 nfsd4_set_ex_flags(struct nfs4_client
*new, struct nfsd4_exchange_id
*clid
)
1096 /* pNFS is not supported */
1097 new->cl_exchange_flags
|= EXCHGID4_FLAG_USE_NON_PNFS
;
1099 /* Referrals are supported, Migration is not. */
1100 new->cl_exchange_flags
|= EXCHGID4_FLAG_SUPP_MOVED_REFER
;
1102 /* set the wire flags to return to client. */
1103 clid
->flags
= new->cl_exchange_flags
;
1107 nfsd4_exchange_id(struct svc_rqst
*rqstp
,
1108 struct nfsd4_compound_state
*cstate
,
1109 struct nfsd4_exchange_id
*exid
)
1111 struct nfs4_client
*unconf
, *conf
, *new;
1113 unsigned int strhashval
;
1114 char dname
[HEXDIR_LEN
];
1115 char addr_str
[INET6_ADDRSTRLEN
];
1116 nfs4_verifier verf
= exid
->verifier
;
1117 struct sockaddr
*sa
= svc_addr(rqstp
);
1119 rpc_ntop(sa
, addr_str
, sizeof(addr_str
));
1120 dprintk("%s rqstp=%p exid=%p clname.len=%u clname.data=%p "
1121 "ip_addr=%s flags %x, spa_how %d\n",
1122 __func__
, rqstp
, exid
, exid
->clname
.len
, exid
->clname
.data
,
1123 addr_str
, exid
->flags
, exid
->spa_how
);
1125 if (!check_name(exid
->clname
) || (exid
->flags
& ~EXCHGID4_FLAG_MASK_A
))
1126 return nfserr_inval
;
1128 /* Currently only support SP4_NONE */
1129 switch (exid
->spa_how
) {
1133 return nfserr_encr_alg_unsupp
;
1135 BUG(); /* checked by xdr code */
1137 return nfserr_serverfault
; /* no excuse :-/ */
1140 status
= nfs4_make_rec_clidname(dname
, &exid
->clname
);
1145 strhashval
= clientstr_hashval(dname
);
1150 conf
= find_confirmed_client_by_str(dname
, strhashval
, true);
1152 if (!same_verf(&verf
, &conf
->cl_verifier
)) {
1153 /* 18.35.4 case 8 */
1154 if (exid
->flags
& EXCHGID4_FLAG_UPD_CONFIRMED_REC_A
) {
1155 status
= nfserr_not_same
;
1158 /* Client reboot: destroy old state */
1159 expire_client(conf
);
1162 if (!same_creds(&conf
->cl_cred
, &rqstp
->rq_cred
)) {
1163 /* 18.35.4 case 9 */
1164 if (exid
->flags
& EXCHGID4_FLAG_UPD_CONFIRMED_REC_A
) {
1165 status
= nfserr_perm
;
1168 expire_client(conf
);
1172 * Set bit when the owner id and verifier map to an already
1173 * confirmed client id (18.35.3).
1175 exid
->flags
|= EXCHGID4_FLAG_CONFIRMED_R
;
1178 * Falling into 18.35.4 case 2, possible router replay.
1179 * Leave confirmed record intact and return same result.
1181 copy_verf(conf
, &verf
);
1186 /* 18.35.4 case 7 */
1187 if (exid
->flags
& EXCHGID4_FLAG_UPD_CONFIRMED_REC_A
) {
1188 status
= nfserr_noent
;
1192 unconf
= find_unconfirmed_client_by_str(dname
, strhashval
, true);
1195 * Possible retry or client restart. Per 18.35.4 case 4,
1196 * a new unconfirmed record should be generated regardless
1197 * of whether any properties have changed.
1199 expire_client(unconf
);
1204 new = create_client(exid
->clname
, dname
, rqstp
, &verf
);
1206 status
= nfserr_serverfault
;
1211 add_to_unconfirmed(new, strhashval
);
1213 exid
->clientid
.cl_boot
= new->cl_clientid
.cl_boot
;
1214 exid
->clientid
.cl_id
= new->cl_clientid
.cl_id
;
1217 nfsd4_set_ex_flags(new, exid
);
1219 dprintk("nfsd4_exchange_id seqid %d flags %x\n",
1220 new->cl_cs_slot
.sl_seqid
, new->cl_exchange_flags
);
1224 nfs4_unlock_state();
1226 dprintk("nfsd4_exchange_id returns %d\n", ntohl(status
));
1231 check_slot_seqid(u32 seqid
, u32 slot_seqid
, int slot_inuse
)
1233 dprintk("%s enter. seqid %d slot_seqid %d\n", __func__
, seqid
,
1236 /* The slot is in use, and no response has been sent. */
1238 if (seqid
== slot_seqid
)
1239 return nfserr_jukebox
;
1241 return nfserr_seq_misordered
;
1244 if (likely(seqid
== slot_seqid
+ 1))
1247 if (seqid
== slot_seqid
)
1248 return nfserr_replay_cache
;
1250 if (seqid
== 1 && (slot_seqid
+ 1) == 0)
1252 /* Misordered replay or misordered new request */
1253 return nfserr_seq_misordered
;
1257 * Cache the create session result into the create session single DRC
1258 * slot cache by saving the xdr structure. sl_seqid has been set.
1259 * Do this for solo or embedded create session operations.
1262 nfsd4_cache_create_session(struct nfsd4_create_session
*cr_ses
,
1263 struct nfsd4_clid_slot
*slot
, int nfserr
)
1265 slot
->sl_status
= nfserr
;
1266 memcpy(&slot
->sl_cr_ses
, cr_ses
, sizeof(*cr_ses
));
1270 nfsd4_replay_create_session(struct nfsd4_create_session
*cr_ses
,
1271 struct nfsd4_clid_slot
*slot
)
1273 memcpy(cr_ses
, &slot
->sl_cr_ses
, sizeof(*cr_ses
));
1274 return slot
->sl_status
;
1278 nfsd4_create_session(struct svc_rqst
*rqstp
,
1279 struct nfsd4_compound_state
*cstate
,
1280 struct nfsd4_create_session
*cr_ses
)
1282 struct sockaddr
*sa
= svc_addr(rqstp
);
1283 struct nfs4_client
*conf
, *unconf
;
1284 struct nfsd4_clid_slot
*cs_slot
= NULL
;
1288 unconf
= find_unconfirmed_client(&cr_ses
->clientid
);
1289 conf
= find_confirmed_client(&cr_ses
->clientid
);
1292 cs_slot
= &conf
->cl_cs_slot
;
1293 status
= check_slot_seqid(cr_ses
->seqid
, cs_slot
->sl_seqid
, 0);
1294 if (status
== nfserr_replay_cache
) {
1295 dprintk("Got a create_session replay! seqid= %d\n",
1297 /* Return the cached reply status */
1298 status
= nfsd4_replay_create_session(cr_ses
, cs_slot
);
1300 } else if (cr_ses
->seqid
!= cs_slot
->sl_seqid
+ 1) {
1301 status
= nfserr_seq_misordered
;
1302 dprintk("Sequence misordered!\n");
1303 dprintk("Expected seqid= %d but got seqid= %d\n",
1304 cs_slot
->sl_seqid
, cr_ses
->seqid
);
1307 cs_slot
->sl_seqid
++;
1308 } else if (unconf
) {
1309 if (!same_creds(&unconf
->cl_cred
, &rqstp
->rq_cred
) ||
1310 !rpc_cmp_addr(sa
, (struct sockaddr
*) &unconf
->cl_addr
)) {
1311 status
= nfserr_clid_inuse
;
1315 cs_slot
= &unconf
->cl_cs_slot
;
1316 status
= check_slot_seqid(cr_ses
->seqid
, cs_slot
->sl_seqid
, 0);
1318 /* an unconfirmed replay returns misordered */
1319 status
= nfserr_seq_misordered
;
1323 cs_slot
->sl_seqid
++; /* from 0 to 1 */
1324 move_to_confirmed(unconf
);
1327 * We do not support RDMA or persistent sessions
1329 cr_ses
->flags
&= ~SESSION4_PERSIST
;
1330 cr_ses
->flags
&= ~SESSION4_RDMA
;
1332 if (cr_ses
->flags
& SESSION4_BACK_CHAN
) {
1333 unconf
->cl_cb_xprt
= rqstp
->rq_xprt
;
1334 svc_xprt_get(unconf
->cl_cb_xprt
);
1336 (struct sockaddr
*)&unconf
->cl_cb_conn
.cb_addr
,
1338 unconf
->cl_cb_conn
.cb_addrlen
= svc_addr_len(sa
);
1339 unconf
->cl_cb_conn
.cb_minorversion
=
1340 cstate
->minorversion
;
1341 unconf
->cl_cb_conn
.cb_prog
= cr_ses
->callback_prog
;
1342 unconf
->cl_cb_seq_nr
= 1;
1343 nfsd4_probe_callback(unconf
);
1347 status
= nfserr_stale_clientid
;
1351 status
= alloc_init_session(rqstp
, conf
, cr_ses
);
1355 memcpy(cr_ses
->sessionid
.data
, conf
->cl_sessionid
.data
,
1356 NFS4_MAX_SESSIONID_LEN
);
1357 cr_ses
->seqid
= cs_slot
->sl_seqid
;
1360 /* cache solo and embedded create sessions under the state lock */
1361 nfsd4_cache_create_session(cr_ses
, cs_slot
, status
);
1363 nfs4_unlock_state();
1364 dprintk("%s returns %d\n", __func__
, ntohl(status
));
1369 nfsd4_destroy_session(struct svc_rqst
*r
,
1370 struct nfsd4_compound_state
*cstate
,
1371 struct nfsd4_destroy_session
*sessionid
)
1373 struct nfsd4_session
*ses
;
1374 u32 status
= nfserr_badsession
;
1377 * - The confirmed nfs4_client->cl_sessionid holds destroyed sessinid
1378 * - Should we return nfserr_back_chan_busy if waiting for
1379 * callbacks on to-be-destroyed session?
1380 * - Do we need to clear any callback info from previous session?
1383 dump_sessionid(__func__
, &sessionid
->sessionid
);
1384 spin_lock(&sessionid_lock
);
1385 ses
= find_in_sessionid_hashtbl(&sessionid
->sessionid
);
1387 spin_unlock(&sessionid_lock
);
1391 unhash_session(ses
);
1392 spin_unlock(&sessionid_lock
);
1394 /* wait for callbacks */
1395 shutdown_callback_client(ses
->se_client
);
1396 nfsd4_put_session(ses
);
1399 dprintk("%s returns %d\n", __func__
, ntohl(status
));
1404 nfsd4_sequence(struct svc_rqst
*rqstp
,
1405 struct nfsd4_compound_state
*cstate
,
1406 struct nfsd4_sequence
*seq
)
1408 struct nfsd4_compoundres
*resp
= rqstp
->rq_resp
;
1409 struct nfsd4_session
*session
;
1410 struct nfsd4_slot
*slot
;
1413 if (resp
->opcnt
!= 1)
1414 return nfserr_sequence_pos
;
1416 spin_lock(&sessionid_lock
);
1417 status
= nfserr_badsession
;
1418 session
= find_in_sessionid_hashtbl(&seq
->sessionid
);
1422 status
= nfserr_badslot
;
1423 if (seq
->slotid
>= session
->se_fchannel
.maxreqs
)
1426 slot
= session
->se_slots
[seq
->slotid
];
1427 dprintk("%s: slotid %d\n", __func__
, seq
->slotid
);
1429 /* We do not negotiate the number of slots yet, so set the
1430 * maxslots to the session maxreqs which is used to encode
1431 * sr_highest_slotid and the sr_target_slot id to maxslots */
1432 seq
->maxslots
= session
->se_fchannel
.maxreqs
;
1434 status
= check_slot_seqid(seq
->seqid
, slot
->sl_seqid
, slot
->sl_inuse
);
1435 if (status
== nfserr_replay_cache
) {
1436 cstate
->slot
= slot
;
1437 cstate
->session
= session
;
1438 /* Return the cached reply status and set cstate->status
1439 * for nfsd4_proc_compound processing */
1440 status
= nfsd4_replay_cache_entry(resp
, seq
);
1441 cstate
->status
= nfserr_replay_cache
;
1447 /* Success! bump slot seqid */
1448 slot
->sl_inuse
= true;
1449 slot
->sl_seqid
= seq
->seqid
;
1450 slot
->sl_cachethis
= seq
->cachethis
;
1452 cstate
->slot
= slot
;
1453 cstate
->session
= session
;
1455 /* Hold a session reference until done processing the compound:
1456 * nfsd4_put_session called only if the cstate slot is set.
1458 nfsd4_get_session(session
);
1460 spin_unlock(&sessionid_lock
);
1461 /* Renew the clientid on success and on replay */
1462 if (cstate
->session
) {
1464 renew_client(session
->se_client
);
1465 nfs4_unlock_state();
1467 dprintk("%s: return %d\n", __func__
, ntohl(status
));
1472 nfsd4_setclientid(struct svc_rqst
*rqstp
, struct nfsd4_compound_state
*cstate
,
1473 struct nfsd4_setclientid
*setclid
)
1475 struct sockaddr
*sa
= svc_addr(rqstp
);
1476 struct xdr_netobj clname
= {
1477 .len
= setclid
->se_namelen
,
1478 .data
= setclid
->se_name
,
1480 nfs4_verifier clverifier
= setclid
->se_verf
;
1481 unsigned int strhashval
;
1482 struct nfs4_client
*conf
, *unconf
, *new;
1484 char dname
[HEXDIR_LEN
];
1486 if (!check_name(clname
))
1487 return nfserr_inval
;
1489 status
= nfs4_make_rec_clidname(dname
, &clname
);
1494 * XXX The Duplicate Request Cache (DRC) has been checked (??)
1495 * We get here on a DRC miss.
1498 strhashval
= clientstr_hashval(dname
);
1501 conf
= find_confirmed_client_by_str(dname
, strhashval
, false);
1503 /* RFC 3530 14.2.33 CASE 0: */
1504 status
= nfserr_clid_inuse
;
1505 if (!same_creds(&conf
->cl_cred
, &rqstp
->rq_cred
)) {
1506 char addr_str
[INET6_ADDRSTRLEN
];
1507 rpc_ntop((struct sockaddr
*) &conf
->cl_addr
, addr_str
,
1509 dprintk("NFSD: setclientid: string in use by client "
1510 "at %s\n", addr_str
);
1515 * section 14.2.33 of RFC 3530 (under the heading "IMPLEMENTATION")
1516 * has a description of SETCLIENTID request processing consisting
1517 * of 5 bullet points, labeled as CASE0 - CASE4 below.
1519 unconf
= find_unconfirmed_client_by_str(dname
, strhashval
, false);
1520 status
= nfserr_resource
;
1523 * RFC 3530 14.2.33 CASE 4:
1524 * placed first, because it is the normal case
1527 expire_client(unconf
);
1528 new = create_client(clname
, dname
, rqstp
, &clverifier
);
1532 } else if (same_verf(&conf
->cl_verifier
, &clverifier
)) {
1534 * RFC 3530 14.2.33 CASE 1:
1535 * probable callback update
1538 /* Note this is removing unconfirmed {*x***},
1539 * which is stronger than RFC recommended {vxc**}.
1540 * This has the advantage that there is at most
1541 * one {*x***} in either list at any time.
1543 expire_client(unconf
);
1545 new = create_client(clname
, dname
, rqstp
, &clverifier
);
1548 copy_clid(new, conf
);
1549 } else if (!unconf
) {
1551 * RFC 3530 14.2.33 CASE 2:
1552 * probable client reboot; state will be removed if
1555 new = create_client(clname
, dname
, rqstp
, &clverifier
);
1561 * RFC 3530 14.2.33 CASE 3:
1562 * probable client reboot; state will be removed if
1565 expire_client(unconf
);
1566 new = create_client(clname
, dname
, rqstp
, &clverifier
);
1571 gen_callback(new, setclid
, rpc_get_scope_id(sa
));
1572 add_to_unconfirmed(new, strhashval
);
1573 setclid
->se_clientid
.cl_boot
= new->cl_clientid
.cl_boot
;
1574 setclid
->se_clientid
.cl_id
= new->cl_clientid
.cl_id
;
1575 memcpy(setclid
->se_confirm
.data
, new->cl_confirm
.data
, sizeof(setclid
->se_confirm
.data
));
1578 nfs4_unlock_state();
1584 * Section 14.2.34 of RFC 3530 (under the heading "IMPLEMENTATION") has
1585 * a description of SETCLIENTID_CONFIRM request processing consisting of 4
1586 * bullets, labeled as CASE1 - CASE4 below.
1589 nfsd4_setclientid_confirm(struct svc_rqst
*rqstp
,
1590 struct nfsd4_compound_state
*cstate
,
1591 struct nfsd4_setclientid_confirm
*setclientid_confirm
)
1593 struct sockaddr
*sa
= svc_addr(rqstp
);
1594 struct nfs4_client
*conf
, *unconf
;
1595 nfs4_verifier confirm
= setclientid_confirm
->sc_confirm
;
1596 clientid_t
* clid
= &setclientid_confirm
->sc_clientid
;
1599 if (STALE_CLIENTID(clid
))
1600 return nfserr_stale_clientid
;
1602 * XXX The Duplicate Request Cache (DRC) has been checked (??)
1603 * We get here on a DRC miss.
1608 conf
= find_confirmed_client(clid
);
1609 unconf
= find_unconfirmed_client(clid
);
1611 status
= nfserr_clid_inuse
;
1612 if (conf
&& !rpc_cmp_addr((struct sockaddr
*) &conf
->cl_addr
, sa
))
1614 if (unconf
&& !rpc_cmp_addr((struct sockaddr
*) &unconf
->cl_addr
, sa
))
1618 * section 14.2.34 of RFC 3530 has a description of
1619 * SETCLIENTID_CONFIRM request processing consisting
1620 * of 4 bullet points, labeled as CASE1 - CASE4 below.
1622 if (conf
&& unconf
&& same_verf(&confirm
, &unconf
->cl_confirm
)) {
1624 * RFC 3530 14.2.34 CASE 1:
1627 if (!same_creds(&conf
->cl_cred
, &unconf
->cl_cred
))
1628 status
= nfserr_clid_inuse
;
1630 /* XXX: We just turn off callbacks until we can handle
1631 * change request correctly. */
1632 atomic_set(&conf
->cl_cb_conn
.cb_set
, 0);
1633 expire_client(unconf
);
1637 } else if (conf
&& !unconf
) {
1639 * RFC 3530 14.2.34 CASE 2:
1640 * probable retransmitted request; play it safe and
1643 if (!same_creds(&conf
->cl_cred
, &rqstp
->rq_cred
))
1644 status
= nfserr_clid_inuse
;
1647 } else if (!conf
&& unconf
1648 && same_verf(&unconf
->cl_confirm
, &confirm
)) {
1650 * RFC 3530 14.2.34 CASE 3:
1651 * Normal case; new or rebooted client:
1653 if (!same_creds(&unconf
->cl_cred
, &rqstp
->rq_cred
)) {
1654 status
= nfserr_clid_inuse
;
1657 clientstr_hashval(unconf
->cl_recdir
);
1658 conf
= find_confirmed_client_by_str(unconf
->cl_recdir
,
1661 nfsd4_remove_clid_dir(conf
);
1662 expire_client(conf
);
1664 move_to_confirmed(unconf
);
1666 nfsd4_probe_callback(conf
);
1669 } else if ((!conf
|| (conf
&& !same_verf(&conf
->cl_confirm
, &confirm
)))
1670 && (!unconf
|| (unconf
&& !same_verf(&unconf
->cl_confirm
,
1673 * RFC 3530 14.2.34 CASE 4:
1674 * Client probably hasn't noticed that we rebooted yet.
1676 status
= nfserr_stale_clientid
;
1678 /* check that we have hit one of the cases...*/
1679 status
= nfserr_clid_inuse
;
1682 nfs4_unlock_state();
1686 /* OPEN Share state helper functions */
1687 static inline struct nfs4_file
*
1688 alloc_init_file(struct inode
*ino
)
1690 struct nfs4_file
*fp
;
1691 unsigned int hashval
= file_hashval(ino
);
1693 fp
= kmem_cache_alloc(file_slab
, GFP_KERNEL
);
1695 atomic_set(&fp
->fi_ref
, 1);
1696 INIT_LIST_HEAD(&fp
->fi_hash
);
1697 INIT_LIST_HEAD(&fp
->fi_stateids
);
1698 INIT_LIST_HEAD(&fp
->fi_delegations
);
1699 spin_lock(&recall_lock
);
1700 list_add(&fp
->fi_hash
, &file_hashtbl
[hashval
]);
1701 spin_unlock(&recall_lock
);
1702 fp
->fi_inode
= igrab(ino
);
1703 fp
->fi_id
= current_fileid
++;
1704 fp
->fi_had_conflict
= false;
1711 nfsd4_free_slab(struct kmem_cache
**slab
)
1715 kmem_cache_destroy(*slab
);
1720 nfsd4_free_slabs(void)
1722 nfsd4_free_slab(&stateowner_slab
);
1723 nfsd4_free_slab(&file_slab
);
1724 nfsd4_free_slab(&stateid_slab
);
1725 nfsd4_free_slab(&deleg_slab
);
1729 nfsd4_init_slabs(void)
1731 stateowner_slab
= kmem_cache_create("nfsd4_stateowners",
1732 sizeof(struct nfs4_stateowner
), 0, 0, NULL
);
1733 if (stateowner_slab
== NULL
)
1735 file_slab
= kmem_cache_create("nfsd4_files",
1736 sizeof(struct nfs4_file
), 0, 0, NULL
);
1737 if (file_slab
== NULL
)
1739 stateid_slab
= kmem_cache_create("nfsd4_stateids",
1740 sizeof(struct nfs4_stateid
), 0, 0, NULL
);
1741 if (stateid_slab
== NULL
)
1743 deleg_slab
= kmem_cache_create("nfsd4_delegations",
1744 sizeof(struct nfs4_delegation
), 0, 0, NULL
);
1745 if (deleg_slab
== NULL
)
1750 dprintk("nfsd4: out of memory while initializing nfsv4\n");
1755 nfs4_free_stateowner(struct kref
*kref
)
1757 struct nfs4_stateowner
*sop
=
1758 container_of(kref
, struct nfs4_stateowner
, so_ref
);
1759 kfree(sop
->so_owner
.data
);
1760 kmem_cache_free(stateowner_slab
, sop
);
1763 static inline struct nfs4_stateowner
*
1764 alloc_stateowner(struct xdr_netobj
*owner
)
1766 struct nfs4_stateowner
*sop
;
1768 if ((sop
= kmem_cache_alloc(stateowner_slab
, GFP_KERNEL
))) {
1769 if ((sop
->so_owner
.data
= kmalloc(owner
->len
, GFP_KERNEL
))) {
1770 memcpy(sop
->so_owner
.data
, owner
->data
, owner
->len
);
1771 sop
->so_owner
.len
= owner
->len
;
1772 kref_init(&sop
->so_ref
);
1775 kmem_cache_free(stateowner_slab
, sop
);
1780 static struct nfs4_stateowner
*
1781 alloc_init_open_stateowner(unsigned int strhashval
, struct nfs4_client
*clp
, struct nfsd4_open
*open
) {
1782 struct nfs4_stateowner
*sop
;
1783 struct nfs4_replay
*rp
;
1784 unsigned int idhashval
;
1786 if (!(sop
= alloc_stateowner(&open
->op_owner
)))
1788 idhashval
= ownerid_hashval(current_ownerid
);
1789 INIT_LIST_HEAD(&sop
->so_idhash
);
1790 INIT_LIST_HEAD(&sop
->so_strhash
);
1791 INIT_LIST_HEAD(&sop
->so_perclient
);
1792 INIT_LIST_HEAD(&sop
->so_stateids
);
1793 INIT_LIST_HEAD(&sop
->so_perstateid
); /* not used */
1794 INIT_LIST_HEAD(&sop
->so_close_lru
);
1796 list_add(&sop
->so_idhash
, &ownerid_hashtbl
[idhashval
]);
1797 list_add(&sop
->so_strhash
, &ownerstr_hashtbl
[strhashval
]);
1798 list_add(&sop
->so_perclient
, &clp
->cl_openowners
);
1799 sop
->so_is_open_owner
= 1;
1800 sop
->so_id
= current_ownerid
++;
1801 sop
->so_client
= clp
;
1802 sop
->so_seqid
= open
->op_seqid
;
1803 sop
->so_confirmed
= 0;
1804 rp
= &sop
->so_replay
;
1805 rp
->rp_status
= nfserr_serverfault
;
1807 rp
->rp_buf
= rp
->rp_ibuf
;
1812 init_stateid(struct nfs4_stateid
*stp
, struct nfs4_file
*fp
, struct nfsd4_open
*open
) {
1813 struct nfs4_stateowner
*sop
= open
->op_stateowner
;
1814 unsigned int hashval
= stateid_hashval(sop
->so_id
, fp
->fi_id
);
1816 INIT_LIST_HEAD(&stp
->st_hash
);
1817 INIT_LIST_HEAD(&stp
->st_perstateowner
);
1818 INIT_LIST_HEAD(&stp
->st_lockowners
);
1819 INIT_LIST_HEAD(&stp
->st_perfile
);
1820 list_add(&stp
->st_hash
, &stateid_hashtbl
[hashval
]);
1821 list_add(&stp
->st_perstateowner
, &sop
->so_stateids
);
1822 list_add(&stp
->st_perfile
, &fp
->fi_stateids
);
1823 stp
->st_stateowner
= sop
;
1826 stp
->st_stateid
.si_boot
= get_seconds();
1827 stp
->st_stateid
.si_stateownerid
= sop
->so_id
;
1828 stp
->st_stateid
.si_fileid
= fp
->fi_id
;
1829 stp
->st_stateid
.si_generation
= 0;
1830 stp
->st_access_bmap
= 0;
1831 stp
->st_deny_bmap
= 0;
1832 __set_bit(open
->op_share_access
& ~NFS4_SHARE_WANT_MASK
,
1833 &stp
->st_access_bmap
);
1834 __set_bit(open
->op_share_deny
, &stp
->st_deny_bmap
);
1835 stp
->st_openstp
= NULL
;
1839 move_to_close_lru(struct nfs4_stateowner
*sop
)
1841 dprintk("NFSD: move_to_close_lru nfs4_stateowner %p\n", sop
);
1843 list_move_tail(&sop
->so_close_lru
, &close_lru
);
1844 sop
->so_time
= get_seconds();
1848 same_owner_str(struct nfs4_stateowner
*sop
, struct xdr_netobj
*owner
,
1851 return (sop
->so_owner
.len
== owner
->len
) &&
1852 0 == memcmp(sop
->so_owner
.data
, owner
->data
, owner
->len
) &&
1853 (sop
->so_client
->cl_clientid
.cl_id
== clid
->cl_id
);
1856 static struct nfs4_stateowner
*
1857 find_openstateowner_str(unsigned int hashval
, struct nfsd4_open
*open
)
1859 struct nfs4_stateowner
*so
= NULL
;
1861 list_for_each_entry(so
, &ownerstr_hashtbl
[hashval
], so_strhash
) {
1862 if (same_owner_str(so
, &open
->op_owner
, &open
->op_clientid
))
1868 /* search file_hashtbl[] for file */
1869 static struct nfs4_file
*
1870 find_file(struct inode
*ino
)
1872 unsigned int hashval
= file_hashval(ino
);
1873 struct nfs4_file
*fp
;
1875 spin_lock(&recall_lock
);
1876 list_for_each_entry(fp
, &file_hashtbl
[hashval
], fi_hash
) {
1877 if (fp
->fi_inode
== ino
) {
1879 spin_unlock(&recall_lock
);
1883 spin_unlock(&recall_lock
);
1887 static inline int access_valid(u32 x
, u32 minorversion
)
1889 if ((x
& NFS4_SHARE_ACCESS_MASK
) < NFS4_SHARE_ACCESS_READ
)
1891 if ((x
& NFS4_SHARE_ACCESS_MASK
) > NFS4_SHARE_ACCESS_BOTH
)
1893 x
&= ~NFS4_SHARE_ACCESS_MASK
;
1894 if (minorversion
&& x
) {
1895 if ((x
& NFS4_SHARE_WANT_MASK
) > NFS4_SHARE_WANT_CANCEL
)
1897 if ((x
& NFS4_SHARE_WHEN_MASK
) > NFS4_SHARE_PUSH_DELEG_WHEN_UNCONTENDED
)
1899 x
&= ~(NFS4_SHARE_WANT_MASK
| NFS4_SHARE_WHEN_MASK
);
1906 static inline int deny_valid(u32 x
)
1908 /* Note: unlike access bits, deny bits may be zero. */
1909 return x
<= NFS4_SHARE_DENY_BOTH
;
1913 * We store the NONE, READ, WRITE, and BOTH bits separately in the
1914 * st_{access,deny}_bmap field of the stateid, in order to track not
1915 * only what share bits are currently in force, but also what
1916 * combinations of share bits previous opens have used. This allows us
1917 * to enforce the recommendation of rfc 3530 14.2.19 that the server
1918 * return an error if the client attempt to downgrade to a combination
1919 * of share bits not explicable by closing some of its previous opens.
1921 * XXX: This enforcement is actually incomplete, since we don't keep
1922 * track of access/deny bit combinations; so, e.g., we allow:
1924 * OPEN allow read, deny write
1925 * OPEN allow both, deny none
1926 * DOWNGRADE allow read, deny none
1928 * which we should reject.
1931 set_access(unsigned int *access
, unsigned long bmap
) {
1935 for (i
= 1; i
< 4; i
++) {
1936 if (test_bit(i
, &bmap
))
1942 set_deny(unsigned int *deny
, unsigned long bmap
) {
1946 for (i
= 0; i
< 4; i
++) {
1947 if (test_bit(i
, &bmap
))
1953 test_share(struct nfs4_stateid
*stp
, struct nfsd4_open
*open
) {
1954 unsigned int access
, deny
;
1956 set_access(&access
, stp
->st_access_bmap
);
1957 set_deny(&deny
, stp
->st_deny_bmap
);
1958 if ((access
& open
->op_share_deny
) || (deny
& open
->op_share_access
))
1964 * Called to check deny when READ with all zero stateid or
1965 * WRITE with all zero or all one stateid
1968 nfs4_share_conflict(struct svc_fh
*current_fh
, unsigned int deny_type
)
1970 struct inode
*ino
= current_fh
->fh_dentry
->d_inode
;
1971 struct nfs4_file
*fp
;
1972 struct nfs4_stateid
*stp
;
1975 dprintk("NFSD: nfs4_share_conflict\n");
1977 fp
= find_file(ino
);
1980 ret
= nfserr_locked
;
1981 /* Search for conflicting share reservations */
1982 list_for_each_entry(stp
, &fp
->fi_stateids
, st_perfile
) {
1983 if (test_bit(deny_type
, &stp
->st_deny_bmap
) ||
1984 test_bit(NFS4_SHARE_DENY_BOTH
, &stp
->st_deny_bmap
))
1994 nfs4_file_downgrade(struct file
*filp
, unsigned int share_access
)
1996 if (share_access
& NFS4_SHARE_ACCESS_WRITE
) {
1997 drop_file_write_access(filp
);
1998 spin_lock(&filp
->f_lock
);
1999 filp
->f_mode
= (filp
->f_mode
| FMODE_READ
) & ~FMODE_WRITE
;
2000 spin_unlock(&filp
->f_lock
);
2005 * Spawn a thread to perform a recall on the delegation represented
2006 * by the lease (file_lock)
2008 * Called from break_lease() with lock_kernel() held.
2009 * Note: we assume break_lease will only call this *once* for any given
2013 void nfsd_break_deleg_cb(struct file_lock
*fl
)
2015 struct nfs4_delegation
*dp
= (struct nfs4_delegation
*)fl
->fl_owner
;
2017 dprintk("NFSD nfsd_break_deleg_cb: dp %p fl %p\n",dp
,fl
);
2021 /* We're assuming the state code never drops its reference
2022 * without first removing the lease. Since we're in this lease
2023 * callback (and since the lease code is serialized by the kernel
2024 * lock) we know the server hasn't removed the lease yet, we know
2025 * it's safe to take a reference: */
2026 atomic_inc(&dp
->dl_count
);
2027 atomic_inc(&dp
->dl_client
->cl_count
);
2029 spin_lock(&recall_lock
);
2030 list_add_tail(&dp
->dl_recall_lru
, &del_recall_lru
);
2031 spin_unlock(&recall_lock
);
2033 /* only place dl_time is set. protected by lock_kernel*/
2034 dp
->dl_time
= get_seconds();
2037 * We don't want the locks code to timeout the lease for us;
2038 * we'll remove it ourself if the delegation isn't returned
2041 fl
->fl_break_time
= 0;
2043 dp
->dl_file
->fi_had_conflict
= true;
2044 nfsd4_cb_recall(dp
);
2048 * The file_lock is being reapd.
2050 * Called by locks_free_lock() with lock_kernel() held.
2053 void nfsd_release_deleg_cb(struct file_lock
*fl
)
2055 struct nfs4_delegation
*dp
= (struct nfs4_delegation
*)fl
->fl_owner
;
2057 dprintk("NFSD nfsd_release_deleg_cb: fl %p dp %p dl_count %d\n", fl
,dp
, atomic_read(&dp
->dl_count
));
2059 if (!(fl
->fl_flags
& FL_LEASE
) || !dp
)
2061 dp
->dl_flock
= NULL
;
2065 * Set the delegation file_lock back pointer.
2067 * Called from setlease() with lock_kernel() held.
2070 void nfsd_copy_lock_deleg_cb(struct file_lock
*new, struct file_lock
*fl
)
2072 struct nfs4_delegation
*dp
= (struct nfs4_delegation
*)new->fl_owner
;
2074 dprintk("NFSD: nfsd_copy_lock_deleg_cb: new fl %p dp %p\n", new, dp
);
2081 * Called from setlease() with lock_kernel() held
2084 int nfsd_same_client_deleg_cb(struct file_lock
*onlist
, struct file_lock
*try)
2086 struct nfs4_delegation
*onlistd
=
2087 (struct nfs4_delegation
*)onlist
->fl_owner
;
2088 struct nfs4_delegation
*tryd
=
2089 (struct nfs4_delegation
*)try->fl_owner
;
2091 if (onlist
->fl_lmops
!= try->fl_lmops
)
2094 return onlistd
->dl_client
== tryd
->dl_client
;
2099 int nfsd_change_deleg_cb(struct file_lock
**onlist
, int arg
)
2102 return lease_modify(onlist
, arg
);
2107 static const struct lock_manager_operations nfsd_lease_mng_ops
= {
2108 .fl_break
= nfsd_break_deleg_cb
,
2109 .fl_release_private
= nfsd_release_deleg_cb
,
2110 .fl_copy_lock
= nfsd_copy_lock_deleg_cb
,
2111 .fl_mylease
= nfsd_same_client_deleg_cb
,
2112 .fl_change
= nfsd_change_deleg_cb
,
2117 nfsd4_process_open1(struct nfsd4_compound_state
*cstate
,
2118 struct nfsd4_open
*open
)
2120 clientid_t
*clientid
= &open
->op_clientid
;
2121 struct nfs4_client
*clp
= NULL
;
2122 unsigned int strhashval
;
2123 struct nfs4_stateowner
*sop
= NULL
;
2125 if (!check_name(open
->op_owner
))
2126 return nfserr_inval
;
2128 if (STALE_CLIENTID(&open
->op_clientid
))
2129 return nfserr_stale_clientid
;
2131 strhashval
= ownerstr_hashval(clientid
->cl_id
, open
->op_owner
);
2132 sop
= find_openstateowner_str(strhashval
, open
);
2133 open
->op_stateowner
= sop
;
2135 /* Make sure the client's lease hasn't expired. */
2136 clp
= find_confirmed_client(clientid
);
2138 return nfserr_expired
;
2141 /* When sessions are used, skip open sequenceid processing */
2142 if (nfsd4_has_session(cstate
))
2144 if (!sop
->so_confirmed
) {
2145 /* Replace unconfirmed owners without checking for replay. */
2146 clp
= sop
->so_client
;
2147 release_openowner(sop
);
2148 open
->op_stateowner
= NULL
;
2151 if (open
->op_seqid
== sop
->so_seqid
- 1) {
2152 if (sop
->so_replay
.rp_buflen
)
2153 return nfserr_replay_me
;
2154 /* The original OPEN failed so spectacularly
2155 * that we don't even have replay data saved!
2156 * Therefore, we have no choice but to continue
2157 * processing this OPEN; presumably, we'll
2158 * fail again for the same reason.
2160 dprintk("nfsd4_process_open1: replay with no replay cache\n");
2163 if (open
->op_seqid
!= sop
->so_seqid
)
2164 return nfserr_bad_seqid
;
2166 if (open
->op_stateowner
== NULL
) {
2167 sop
= alloc_init_open_stateowner(strhashval
, clp
, open
);
2169 return nfserr_resource
;
2170 open
->op_stateowner
= sop
;
2172 list_del_init(&sop
->so_close_lru
);
2173 renew_client(sop
->so_client
);
2177 static inline __be32
2178 nfs4_check_delegmode(struct nfs4_delegation
*dp
, int flags
)
2180 if ((flags
& WR_STATE
) && (dp
->dl_type
== NFS4_OPEN_DELEGATE_READ
))
2181 return nfserr_openmode
;
2186 static struct nfs4_delegation
*
2187 find_delegation_file(struct nfs4_file
*fp
, stateid_t
*stid
)
2189 struct nfs4_delegation
*dp
;
2191 list_for_each_entry(dp
, &fp
->fi_delegations
, dl_perfile
) {
2192 if (dp
->dl_stateid
.si_stateownerid
== stid
->si_stateownerid
)
2199 nfs4_check_deleg(struct nfs4_file
*fp
, struct nfsd4_open
*open
,
2200 struct nfs4_delegation
**dp
)
2203 __be32 status
= nfserr_bad_stateid
;
2205 *dp
= find_delegation_file(fp
, &open
->op_delegate_stateid
);
2208 flags
= open
->op_share_access
== NFS4_SHARE_ACCESS_READ
?
2209 RD_STATE
: WR_STATE
;
2210 status
= nfs4_check_delegmode(*dp
, flags
);
2214 if (open
->op_claim_type
!= NFS4_OPEN_CLAIM_DELEGATE_CUR
)
2218 open
->op_stateowner
->so_confirmed
= 1;
2223 nfs4_check_open(struct nfs4_file
*fp
, struct nfsd4_open
*open
, struct nfs4_stateid
**stpp
)
2225 struct nfs4_stateid
*local
;
2226 __be32 status
= nfserr_share_denied
;
2227 struct nfs4_stateowner
*sop
= open
->op_stateowner
;
2229 list_for_each_entry(local
, &fp
->fi_stateids
, st_perfile
) {
2230 /* ignore lock owners */
2231 if (local
->st_stateowner
->so_is_open_owner
== 0)
2233 /* remember if we have seen this open owner */
2234 if (local
->st_stateowner
== sop
)
2236 /* check for conflicting share reservations */
2237 if (!test_share(local
, open
))
2245 static inline struct nfs4_stateid
*
2246 nfs4_alloc_stateid(void)
2248 return kmem_cache_alloc(stateid_slab
, GFP_KERNEL
);
2252 nfs4_new_open(struct svc_rqst
*rqstp
, struct nfs4_stateid
**stpp
,
2253 struct nfs4_delegation
*dp
,
2254 struct svc_fh
*cur_fh
, int flags
)
2256 struct nfs4_stateid
*stp
;
2258 stp
= nfs4_alloc_stateid();
2260 return nfserr_resource
;
2263 get_file(dp
->dl_vfs_file
);
2264 stp
->st_vfs_file
= dp
->dl_vfs_file
;
2267 status
= nfsd_open(rqstp
, cur_fh
, S_IFREG
, flags
,
2270 if (status
== nfserr_dropit
)
2271 status
= nfserr_jukebox
;
2272 kmem_cache_free(stateid_slab
, stp
);
2280 static inline __be32
2281 nfsd4_truncate(struct svc_rqst
*rqstp
, struct svc_fh
*fh
,
2282 struct nfsd4_open
*open
)
2284 struct iattr iattr
= {
2285 .ia_valid
= ATTR_SIZE
,
2288 if (!open
->op_truncate
)
2290 if (!(open
->op_share_access
& NFS4_SHARE_ACCESS_WRITE
))
2291 return nfserr_inval
;
2292 return nfsd_setattr(rqstp
, fh
, &iattr
, 0, (time_t)0);
2296 nfs4_upgrade_open(struct svc_rqst
*rqstp
, struct svc_fh
*cur_fh
, struct nfs4_stateid
*stp
, struct nfsd4_open
*open
)
2298 struct file
*filp
= stp
->st_vfs_file
;
2299 struct inode
*inode
= filp
->f_path
.dentry
->d_inode
;
2300 unsigned int share_access
, new_writer
;
2303 set_access(&share_access
, stp
->st_access_bmap
);
2304 new_writer
= (~share_access
) & open
->op_share_access
2305 & NFS4_SHARE_ACCESS_WRITE
;
2308 int err
= get_write_access(inode
);
2310 return nfserrno(err
);
2311 err
= mnt_want_write(cur_fh
->fh_export
->ex_path
.mnt
);
2313 return nfserrno(err
);
2314 file_take_write(filp
);
2316 status
= nfsd4_truncate(rqstp
, cur_fh
, open
);
2319 put_write_access(inode
);
2322 /* remember the open */
2323 filp
->f_mode
|= open
->op_share_access
;
2324 __set_bit(open
->op_share_access
, &stp
->st_access_bmap
);
2325 __set_bit(open
->op_share_deny
, &stp
->st_deny_bmap
);
2332 nfs4_set_claim_prev(struct nfsd4_open
*open
)
2334 open
->op_stateowner
->so_confirmed
= 1;
2335 open
->op_stateowner
->so_client
->cl_firststate
= 1;
2339 * Attempt to hand out a delegation.
2342 nfs4_open_delegation(struct svc_fh
*fh
, struct nfsd4_open
*open
, struct nfs4_stateid
*stp
)
2344 struct nfs4_delegation
*dp
;
2345 struct nfs4_stateowner
*sop
= stp
->st_stateowner
;
2346 struct nfs4_cb_conn
*cb
= &sop
->so_client
->cl_cb_conn
;
2347 struct file_lock fl
, *flp
= &fl
;
2348 int status
, flag
= 0;
2350 flag
= NFS4_OPEN_DELEGATE_NONE
;
2351 open
->op_recall
= 0;
2352 switch (open
->op_claim_type
) {
2353 case NFS4_OPEN_CLAIM_PREVIOUS
:
2354 if (!atomic_read(&cb
->cb_set
))
2355 open
->op_recall
= 1;
2356 flag
= open
->op_delegate_type
;
2357 if (flag
== NFS4_OPEN_DELEGATE_NONE
)
2360 case NFS4_OPEN_CLAIM_NULL
:
2361 /* Let's not give out any delegations till everyone's
2362 * had the chance to reclaim theirs.... */
2363 if (locks_in_grace())
2365 if (!atomic_read(&cb
->cb_set
) || !sop
->so_confirmed
)
2367 if (open
->op_share_access
& NFS4_SHARE_ACCESS_WRITE
)
2368 flag
= NFS4_OPEN_DELEGATE_WRITE
;
2370 flag
= NFS4_OPEN_DELEGATE_READ
;
2376 dp
= alloc_init_deleg(sop
->so_client
, stp
, fh
, flag
);
2378 flag
= NFS4_OPEN_DELEGATE_NONE
;
2381 locks_init_lock(&fl
);
2382 fl
.fl_lmops
= &nfsd_lease_mng_ops
;
2383 fl
.fl_flags
= FL_LEASE
;
2384 fl
.fl_type
= flag
== NFS4_OPEN_DELEGATE_READ
? F_RDLCK
: F_WRLCK
;
2385 fl
.fl_end
= OFFSET_MAX
;
2386 fl
.fl_owner
= (fl_owner_t
)dp
;
2387 fl
.fl_file
= stp
->st_vfs_file
;
2388 fl
.fl_pid
= current
->tgid
;
2390 /* vfs_setlease checks to see if delegation should be handed out.
2391 * the lock_manager callbacks fl_mylease and fl_change are used
2393 if ((status
= vfs_setlease(stp
->st_vfs_file
, fl
.fl_type
, &flp
))) {
2394 dprintk("NFSD: setlease failed [%d], no delegation\n", status
);
2395 unhash_delegation(dp
);
2396 flag
= NFS4_OPEN_DELEGATE_NONE
;
2400 memcpy(&open
->op_delegate_stateid
, &dp
->dl_stateid
, sizeof(dp
->dl_stateid
));
2402 dprintk("NFSD: delegation stateid=" STATEID_FMT
"\n",
2403 STATEID_VAL(&dp
->dl_stateid
));
2405 if (open
->op_claim_type
== NFS4_OPEN_CLAIM_PREVIOUS
2406 && flag
== NFS4_OPEN_DELEGATE_NONE
2407 && open
->op_delegate_type
!= NFS4_OPEN_DELEGATE_NONE
)
2408 dprintk("NFSD: WARNING: refusing delegation reclaim\n");
2409 open
->op_delegate_type
= flag
;
2413 * called with nfs4_lock_state() held.
2416 nfsd4_process_open2(struct svc_rqst
*rqstp
, struct svc_fh
*current_fh
, struct nfsd4_open
*open
)
2418 struct nfsd4_compoundres
*resp
= rqstp
->rq_resp
;
2419 struct nfs4_file
*fp
= NULL
;
2420 struct inode
*ino
= current_fh
->fh_dentry
->d_inode
;
2421 struct nfs4_stateid
*stp
= NULL
;
2422 struct nfs4_delegation
*dp
= NULL
;
2425 status
= nfserr_inval
;
2426 if (!access_valid(open
->op_share_access
, resp
->cstate
.minorversion
)
2427 || !deny_valid(open
->op_share_deny
))
2430 * Lookup file; if found, lookup stateid and check open request,
2431 * and check for delegations in the process of being recalled.
2432 * If not found, create the nfs4_file struct
2434 fp
= find_file(ino
);
2436 if ((status
= nfs4_check_open(fp
, open
, &stp
)))
2438 status
= nfs4_check_deleg(fp
, open
, &dp
);
2442 status
= nfserr_bad_stateid
;
2443 if (open
->op_claim_type
== NFS4_OPEN_CLAIM_DELEGATE_CUR
)
2445 status
= nfserr_resource
;
2446 fp
= alloc_init_file(ino
);
2452 * OPEN the file, or upgrade an existing OPEN.
2453 * If truncate fails, the OPEN fails.
2456 /* Stateid was found, this is an OPEN upgrade */
2457 status
= nfs4_upgrade_open(rqstp
, current_fh
, stp
, open
);
2460 update_stateid(&stp
->st_stateid
);
2462 /* Stateid was not found, this is a new OPEN */
2464 if (open
->op_share_access
& NFS4_SHARE_ACCESS_READ
)
2465 flags
|= NFSD_MAY_READ
;
2466 if (open
->op_share_access
& NFS4_SHARE_ACCESS_WRITE
)
2467 flags
|= NFSD_MAY_WRITE
;
2468 status
= nfs4_new_open(rqstp
, &stp
, dp
, current_fh
, flags
);
2471 init_stateid(stp
, fp
, open
);
2472 status
= nfsd4_truncate(rqstp
, current_fh
, open
);
2474 release_open_stateid(stp
);
2477 if (nfsd4_has_session(&resp
->cstate
))
2478 update_stateid(&stp
->st_stateid
);
2480 memcpy(&open
->op_stateid
, &stp
->st_stateid
, sizeof(stateid_t
));
2482 if (nfsd4_has_session(&resp
->cstate
)) {
2483 open
->op_stateowner
->so_confirmed
= 1;
2484 nfsd4_create_clid_dir(open
->op_stateowner
->so_client
);
2488 * Attempt to hand out a delegation. No error return, because the
2489 * OPEN succeeds even if we fail.
2491 nfs4_open_delegation(current_fh
, open
, stp
);
2495 dprintk("%s: stateid=" STATEID_FMT
"\n", __func__
,
2496 STATEID_VAL(&stp
->st_stateid
));
2500 if (status
== 0 && open
->op_claim_type
== NFS4_OPEN_CLAIM_PREVIOUS
)
2501 nfs4_set_claim_prev(open
);
2503 * To finish the open response, we just need to set the rflags.
2505 open
->op_rflags
= NFS4_OPEN_RESULT_LOCKTYPE_POSIX
;
2506 if (!open
->op_stateowner
->so_confirmed
&&
2507 !nfsd4_has_session(&resp
->cstate
))
2508 open
->op_rflags
|= NFS4_OPEN_RESULT_CONFIRM
;
2514 nfsd4_renew(struct svc_rqst
*rqstp
, struct nfsd4_compound_state
*cstate
,
2517 struct nfs4_client
*clp
;
2521 dprintk("process_renew(%08x/%08x): starting\n",
2522 clid
->cl_boot
, clid
->cl_id
);
2523 status
= nfserr_stale_clientid
;
2524 if (STALE_CLIENTID(clid
))
2526 clp
= find_confirmed_client(clid
);
2527 status
= nfserr_expired
;
2529 /* We assume the client took too long to RENEW. */
2530 dprintk("nfsd4_renew: clientid not found!\n");
2534 status
= nfserr_cb_path_down
;
2535 if (!list_empty(&clp
->cl_delegations
)
2536 && !atomic_read(&clp
->cl_cb_conn
.cb_set
))
2540 nfs4_unlock_state();
2544 struct lock_manager nfsd4_manager
= {
2548 nfsd4_end_grace(void)
2550 dprintk("NFSD: end of grace period\n");
2551 nfsd4_recdir_purge_old();
2552 locks_end_grace(&nfsd4_manager
);
2554 * Now that every NFSv4 client has had the chance to recover and
2555 * to see the (possibly new, possibly shorter) lease time, we
2556 * can safely set the next grace time to the current lease time:
2558 nfsd4_grace
= nfsd4_lease
;
2562 nfs4_laundromat(void)
2564 struct nfs4_client
*clp
;
2565 struct nfs4_stateowner
*sop
;
2566 struct nfs4_delegation
*dp
;
2567 struct list_head
*pos
, *next
, reaplist
;
2568 time_t cutoff
= get_seconds() - nfsd4_lease
;
2569 time_t t
, clientid_val
= nfsd4_lease
;
2570 time_t u
, test_val
= nfsd4_lease
;
2574 dprintk("NFSD: laundromat service - starting\n");
2575 if (locks_in_grace())
2577 list_for_each_safe(pos
, next
, &client_lru
) {
2578 clp
= list_entry(pos
, struct nfs4_client
, cl_lru
);
2579 if (time_after((unsigned long)clp
->cl_time
, (unsigned long)cutoff
)) {
2580 t
= clp
->cl_time
- cutoff
;
2581 if (clientid_val
> t
)
2585 dprintk("NFSD: purging unused client (clientid %08x)\n",
2586 clp
->cl_clientid
.cl_id
);
2587 nfsd4_remove_clid_dir(clp
);
2590 INIT_LIST_HEAD(&reaplist
);
2591 spin_lock(&recall_lock
);
2592 list_for_each_safe(pos
, next
, &del_recall_lru
) {
2593 dp
= list_entry (pos
, struct nfs4_delegation
, dl_recall_lru
);
2594 if (time_after((unsigned long)dp
->dl_time
, (unsigned long)cutoff
)) {
2595 u
= dp
->dl_time
- cutoff
;
2600 dprintk("NFSD: purging unused delegation dp %p, fp %p\n",
2602 list_move(&dp
->dl_recall_lru
, &reaplist
);
2604 spin_unlock(&recall_lock
);
2605 list_for_each_safe(pos
, next
, &reaplist
) {
2606 dp
= list_entry (pos
, struct nfs4_delegation
, dl_recall_lru
);
2607 list_del_init(&dp
->dl_recall_lru
);
2608 unhash_delegation(dp
);
2610 test_val
= nfsd4_lease
;
2611 list_for_each_safe(pos
, next
, &close_lru
) {
2612 sop
= list_entry(pos
, struct nfs4_stateowner
, so_close_lru
);
2613 if (time_after((unsigned long)sop
->so_time
, (unsigned long)cutoff
)) {
2614 u
= sop
->so_time
- cutoff
;
2619 dprintk("NFSD: purging unused open stateowner (so_id %d)\n",
2621 release_openowner(sop
);
2623 if (clientid_val
< NFSD_LAUNDROMAT_MINTIMEOUT
)
2624 clientid_val
= NFSD_LAUNDROMAT_MINTIMEOUT
;
2625 nfs4_unlock_state();
2626 return clientid_val
;
2629 static struct workqueue_struct
*laundry_wq
;
2630 static void laundromat_main(struct work_struct
*);
2631 static DECLARE_DELAYED_WORK(laundromat_work
, laundromat_main
);
2634 laundromat_main(struct work_struct
*not_used
)
2638 t
= nfs4_laundromat();
2639 dprintk("NFSD: laundromat_main - sleeping for %ld seconds\n", t
);
2640 queue_delayed_work(laundry_wq
, &laundromat_work
, t
*HZ
);
2643 static struct nfs4_stateowner
*
2644 search_close_lru(u32 st_id
, int flags
)
2646 struct nfs4_stateowner
*local
= NULL
;
2648 if (flags
& CLOSE_STATE
) {
2649 list_for_each_entry(local
, &close_lru
, so_close_lru
) {
2650 if (local
->so_id
== st_id
)
2658 nfs4_check_fh(struct svc_fh
*fhp
, struct nfs4_stateid
*stp
)
2660 return fhp
->fh_dentry
->d_inode
!= stp
->st_vfs_file
->f_path
.dentry
->d_inode
;
2664 STALE_STATEID(stateid_t
*stateid
)
2666 if (time_after((unsigned long)boot_time
,
2667 (unsigned long)stateid
->si_boot
)) {
2668 dprintk("NFSD: stale stateid " STATEID_FMT
"!\n",
2669 STATEID_VAL(stateid
));
2676 EXPIRED_STATEID(stateid_t
*stateid
)
2678 if (time_before((unsigned long)boot_time
,
2679 ((unsigned long)stateid
->si_boot
)) &&
2680 time_before((unsigned long)(stateid
->si_boot
+ nfsd4_lease
), get_seconds())) {
2681 dprintk("NFSD: expired stateid " STATEID_FMT
"!\n",
2682 STATEID_VAL(stateid
));
2689 stateid_error_map(stateid_t
*stateid
)
2691 if (STALE_STATEID(stateid
))
2692 return nfserr_stale_stateid
;
2693 if (EXPIRED_STATEID(stateid
))
2694 return nfserr_expired
;
2696 dprintk("NFSD: bad stateid " STATEID_FMT
"!\n",
2697 STATEID_VAL(stateid
));
2698 return nfserr_bad_stateid
;
2702 access_permit_read(unsigned long access_bmap
)
2704 return test_bit(NFS4_SHARE_ACCESS_READ
, &access_bmap
) ||
2705 test_bit(NFS4_SHARE_ACCESS_BOTH
, &access_bmap
) ||
2706 test_bit(NFS4_SHARE_ACCESS_WRITE
, &access_bmap
);
2710 access_permit_write(unsigned long access_bmap
)
2712 return test_bit(NFS4_SHARE_ACCESS_WRITE
, &access_bmap
) ||
2713 test_bit(NFS4_SHARE_ACCESS_BOTH
, &access_bmap
);
2717 __be32
nfs4_check_openmode(struct nfs4_stateid
*stp
, int flags
)
2719 __be32 status
= nfserr_openmode
;
2721 if ((flags
& WR_STATE
) && (!access_permit_write(stp
->st_access_bmap
)))
2723 if ((flags
& RD_STATE
) && (!access_permit_read(stp
->st_access_bmap
)))
2730 static inline __be32
2731 check_special_stateids(svc_fh
*current_fh
, stateid_t
*stateid
, int flags
)
2733 if (ONE_STATEID(stateid
) && (flags
& RD_STATE
))
2735 else if (locks_in_grace()) {
2736 /* Answer in remaining cases depends on existance of
2737 * conflicting state; so we must wait out the grace period. */
2738 return nfserr_grace
;
2739 } else if (flags
& WR_STATE
)
2740 return nfs4_share_conflict(current_fh
,
2741 NFS4_SHARE_DENY_WRITE
);
2742 else /* (flags & RD_STATE) && ZERO_STATEID(stateid) */
2743 return nfs4_share_conflict(current_fh
,
2744 NFS4_SHARE_DENY_READ
);
2748 * Allow READ/WRITE during grace period on recovered state only for files
2749 * that are not able to provide mandatory locking.
2752 grace_disallows_io(struct inode
*inode
)
2754 return locks_in_grace() && mandatory_lock(inode
);
2757 static int check_stateid_generation(stateid_t
*in
, stateid_t
*ref
, int flags
)
2760 * When sessions are used the stateid generation number is ignored
2763 if ((flags
& HAS_SESSION
) && in
->si_generation
== 0)
2766 /* If the client sends us a stateid from the future, it's buggy: */
2767 if (in
->si_generation
> ref
->si_generation
)
2768 return nfserr_bad_stateid
;
2770 * The following, however, can happen. For example, if the
2771 * client sends an open and some IO at the same time, the open
2772 * may bump si_generation while the IO is still in flight.
2773 * Thanks to hard links and renames, the client never knows what
2774 * file an open will affect. So it could avoid that situation
2775 * only by serializing all opens and IO from the same open
2776 * owner. To recover from the old_stateid error, the client
2777 * will just have to retry the IO:
2779 if (in
->si_generation
< ref
->si_generation
)
2780 return nfserr_old_stateid
;
2785 static int is_delegation_stateid(stateid_t
*stateid
)
2787 return stateid
->si_fileid
== 0;
2791 * Checks for stateid operations
2794 nfs4_preprocess_stateid_op(struct nfsd4_compound_state
*cstate
,
2795 stateid_t
*stateid
, int flags
, struct file
**filpp
)
2797 struct nfs4_stateid
*stp
= NULL
;
2798 struct nfs4_delegation
*dp
= NULL
;
2799 struct svc_fh
*current_fh
= &cstate
->current_fh
;
2800 struct inode
*ino
= current_fh
->fh_dentry
->d_inode
;
2806 if (grace_disallows_io(ino
))
2807 return nfserr_grace
;
2809 if (nfsd4_has_session(cstate
))
2810 flags
|= HAS_SESSION
;
2812 if (ZERO_STATEID(stateid
) || ONE_STATEID(stateid
))
2813 return check_special_stateids(current_fh
, stateid
, flags
);
2815 status
= nfserr_stale_stateid
;
2816 if (STALE_STATEID(stateid
))
2819 status
= nfserr_bad_stateid
;
2820 if (is_delegation_stateid(stateid
)) {
2821 dp
= find_delegation_stateid(ino
, stateid
);
2823 status
= stateid_error_map(stateid
);
2826 status
= check_stateid_generation(stateid
, &dp
->dl_stateid
,
2830 status
= nfs4_check_delegmode(dp
, flags
);
2833 renew_client(dp
->dl_client
);
2835 *filpp
= dp
->dl_vfs_file
;
2836 } else { /* open or lock stateid */
2837 stp
= find_stateid(stateid
, flags
);
2839 status
= stateid_error_map(stateid
);
2842 if (nfs4_check_fh(current_fh
, stp
))
2844 if (!stp
->st_stateowner
->so_confirmed
)
2846 status
= check_stateid_generation(stateid
, &stp
->st_stateid
,
2850 status
= nfs4_check_openmode(stp
, flags
);
2853 renew_client(stp
->st_stateowner
->so_client
);
2855 *filpp
= stp
->st_vfs_file
;
2865 return (type
== NFS4_READW_LT
|| type
== NFS4_READ_LT
) ?
2866 RD_STATE
: WR_STATE
;
2870 * Checks for sequence id mutating operations.
2873 nfs4_preprocess_seqid_op(struct nfsd4_compound_state
*cstate
, u32 seqid
,
2874 stateid_t
*stateid
, int flags
,
2875 struct nfs4_stateowner
**sopp
,
2876 struct nfs4_stateid
**stpp
, struct nfsd4_lock
*lock
)
2878 struct nfs4_stateid
*stp
;
2879 struct nfs4_stateowner
*sop
;
2880 struct svc_fh
*current_fh
= &cstate
->current_fh
;
2883 dprintk("NFSD: %s: seqid=%d stateid = " STATEID_FMT
"\n", __func__
,
2884 seqid
, STATEID_VAL(stateid
));
2889 if (ZERO_STATEID(stateid
) || ONE_STATEID(stateid
)) {
2890 dprintk("NFSD: preprocess_seqid_op: magic stateid!\n");
2891 return nfserr_bad_stateid
;
2894 if (STALE_STATEID(stateid
))
2895 return nfserr_stale_stateid
;
2897 if (nfsd4_has_session(cstate
))
2898 flags
|= HAS_SESSION
;
2901 * We return BAD_STATEID if filehandle doesn't match stateid,
2902 * the confirmed flag is incorrecly set, or the generation
2903 * number is incorrect.
2905 stp
= find_stateid(stateid
, flags
);
2908 * Also, we should make sure this isn't just the result of
2911 sop
= search_close_lru(stateid
->si_stateownerid
, flags
);
2913 return stateid_error_map(stateid
);
2919 *sopp
= sop
= stp
->st_stateowner
;
2922 clientid_t
*lockclid
= &lock
->v
.new.clientid
;
2923 struct nfs4_client
*clp
= sop
->so_client
;
2927 lkflg
= setlkflg(lock
->lk_type
);
2929 if (lock
->lk_is_new
) {
2930 if (!sop
->so_is_open_owner
)
2931 return nfserr_bad_stateid
;
2932 if (!(flags
& HAS_SESSION
) &&
2933 !same_clid(&clp
->cl_clientid
, lockclid
))
2934 return nfserr_bad_stateid
;
2935 /* stp is the open stateid */
2936 status
= nfs4_check_openmode(stp
, lkflg
);
2940 /* stp is the lock stateid */
2941 status
= nfs4_check_openmode(stp
->st_openstp
, lkflg
);
2947 if (nfs4_check_fh(current_fh
, stp
)) {
2948 dprintk("NFSD: preprocess_seqid_op: fh-stateid mismatch!\n");
2949 return nfserr_bad_stateid
;
2953 * We now validate the seqid and stateid generation numbers.
2954 * For the moment, we ignore the possibility of
2955 * generation number wraparound.
2957 if (!(flags
& HAS_SESSION
) && seqid
!= sop
->so_seqid
)
2960 if (sop
->so_confirmed
&& flags
& CONFIRM
) {
2961 dprintk("NFSD: preprocess_seqid_op: expected"
2962 " unconfirmed stateowner!\n");
2963 return nfserr_bad_stateid
;
2965 if (!sop
->so_confirmed
&& !(flags
& CONFIRM
)) {
2966 dprintk("NFSD: preprocess_seqid_op: stateowner not"
2967 " confirmed yet!\n");
2968 return nfserr_bad_stateid
;
2970 status
= check_stateid_generation(stateid
, &stp
->st_stateid
, flags
);
2973 renew_client(sop
->so_client
);
2977 if (seqid
== sop
->so_seqid
- 1) {
2978 dprintk("NFSD: preprocess_seqid_op: retransmission?\n");
2979 /* indicate replay to calling function */
2980 return nfserr_replay_me
;
2982 dprintk("NFSD: preprocess_seqid_op: bad seqid (expected %d, got %d)\n",
2983 sop
->so_seqid
, seqid
);
2985 return nfserr_bad_seqid
;
2989 nfsd4_open_confirm(struct svc_rqst
*rqstp
, struct nfsd4_compound_state
*cstate
,
2990 struct nfsd4_open_confirm
*oc
)
2993 struct nfs4_stateowner
*sop
;
2994 struct nfs4_stateid
*stp
;
2996 dprintk("NFSD: nfsd4_open_confirm on file %.*s\n",
2997 (int)cstate
->current_fh
.fh_dentry
->d_name
.len
,
2998 cstate
->current_fh
.fh_dentry
->d_name
.name
);
3000 status
= fh_verify(rqstp
, &cstate
->current_fh
, S_IFREG
, 0);
3006 if ((status
= nfs4_preprocess_seqid_op(cstate
,
3007 oc
->oc_seqid
, &oc
->oc_req_stateid
,
3008 CONFIRM
| OPEN_STATE
,
3009 &oc
->oc_stateowner
, &stp
, NULL
)))
3012 sop
= oc
->oc_stateowner
;
3013 sop
->so_confirmed
= 1;
3014 update_stateid(&stp
->st_stateid
);
3015 memcpy(&oc
->oc_resp_stateid
, &stp
->st_stateid
, sizeof(stateid_t
));
3016 dprintk("NFSD: %s: success, seqid=%d stateid=" STATEID_FMT
"\n",
3017 __func__
, oc
->oc_seqid
, STATEID_VAL(&stp
->st_stateid
));
3019 nfsd4_create_clid_dir(sop
->so_client
);
3021 if (oc
->oc_stateowner
) {
3022 nfs4_get_stateowner(oc
->oc_stateowner
);
3023 cstate
->replay_owner
= oc
->oc_stateowner
;
3025 nfs4_unlock_state();
3031 * unset all bits in union bitmap (bmap) that
3032 * do not exist in share (from successful OPEN_DOWNGRADE)
3035 reset_union_bmap_access(unsigned long access
, unsigned long *bmap
)
3038 for (i
= 1; i
< 4; i
++) {
3039 if ((i
& access
) != i
)
3040 __clear_bit(i
, bmap
);
3045 reset_union_bmap_deny(unsigned long deny
, unsigned long *bmap
)
3048 for (i
= 0; i
< 4; i
++) {
3049 if ((i
& deny
) != i
)
3050 __clear_bit(i
, bmap
);
3055 nfsd4_open_downgrade(struct svc_rqst
*rqstp
,
3056 struct nfsd4_compound_state
*cstate
,
3057 struct nfsd4_open_downgrade
*od
)
3060 struct nfs4_stateid
*stp
;
3061 unsigned int share_access
;
3063 dprintk("NFSD: nfsd4_open_downgrade on file %.*s\n",
3064 (int)cstate
->current_fh
.fh_dentry
->d_name
.len
,
3065 cstate
->current_fh
.fh_dentry
->d_name
.name
);
3067 if (!access_valid(od
->od_share_access
, cstate
->minorversion
)
3068 || !deny_valid(od
->od_share_deny
))
3069 return nfserr_inval
;
3072 if ((status
= nfs4_preprocess_seqid_op(cstate
,
3076 &od
->od_stateowner
, &stp
, NULL
)))
3079 status
= nfserr_inval
;
3080 if (!test_bit(od
->od_share_access
, &stp
->st_access_bmap
)) {
3081 dprintk("NFSD:access not a subset current bitmap: 0x%lx, input access=%08x\n",
3082 stp
->st_access_bmap
, od
->od_share_access
);
3085 if (!test_bit(od
->od_share_deny
, &stp
->st_deny_bmap
)) {
3086 dprintk("NFSD:deny not a subset current bitmap: 0x%lx, input deny=%08x\n",
3087 stp
->st_deny_bmap
, od
->od_share_deny
);
3090 set_access(&share_access
, stp
->st_access_bmap
);
3091 nfs4_file_downgrade(stp
->st_vfs_file
,
3092 share_access
& ~od
->od_share_access
);
3094 reset_union_bmap_access(od
->od_share_access
, &stp
->st_access_bmap
);
3095 reset_union_bmap_deny(od
->od_share_deny
, &stp
->st_deny_bmap
);
3097 update_stateid(&stp
->st_stateid
);
3098 memcpy(&od
->od_stateid
, &stp
->st_stateid
, sizeof(stateid_t
));
3101 if (od
->od_stateowner
) {
3102 nfs4_get_stateowner(od
->od_stateowner
);
3103 cstate
->replay_owner
= od
->od_stateowner
;
3105 nfs4_unlock_state();
3110 * nfs4_unlock_state() called after encode
3113 nfsd4_close(struct svc_rqst
*rqstp
, struct nfsd4_compound_state
*cstate
,
3114 struct nfsd4_close
*close
)
3117 struct nfs4_stateid
*stp
;
3119 dprintk("NFSD: nfsd4_close on file %.*s\n",
3120 (int)cstate
->current_fh
.fh_dentry
->d_name
.len
,
3121 cstate
->current_fh
.fh_dentry
->d_name
.name
);
3124 /* check close_lru for replay */
3125 if ((status
= nfs4_preprocess_seqid_op(cstate
,
3128 OPEN_STATE
| CLOSE_STATE
,
3129 &close
->cl_stateowner
, &stp
, NULL
)))
3132 update_stateid(&stp
->st_stateid
);
3133 memcpy(&close
->cl_stateid
, &stp
->st_stateid
, sizeof(stateid_t
));
3135 /* release_stateid() calls nfsd_close() if needed */
3136 release_open_stateid(stp
);
3138 /* place unused nfs4_stateowners on so_close_lru list to be
3139 * released by the laundromat service after the lease period
3140 * to enable us to handle CLOSE replay
3142 if (list_empty(&close
->cl_stateowner
->so_stateids
))
3143 move_to_close_lru(close
->cl_stateowner
);
3145 if (close
->cl_stateowner
) {
3146 nfs4_get_stateowner(close
->cl_stateowner
);
3147 cstate
->replay_owner
= close
->cl_stateowner
;
3149 nfs4_unlock_state();
3154 nfsd4_delegreturn(struct svc_rqst
*rqstp
, struct nfsd4_compound_state
*cstate
,
3155 struct nfsd4_delegreturn
*dr
)
3157 struct nfs4_delegation
*dp
;
3158 stateid_t
*stateid
= &dr
->dr_stateid
;
3159 struct inode
*inode
;
3163 if ((status
= fh_verify(rqstp
, &cstate
->current_fh
, S_IFREG
, 0)))
3165 inode
= cstate
->current_fh
.fh_dentry
->d_inode
;
3167 if (nfsd4_has_session(cstate
))
3168 flags
|= HAS_SESSION
;
3170 status
= nfserr_bad_stateid
;
3171 if (ZERO_STATEID(stateid
) || ONE_STATEID(stateid
))
3173 status
= nfserr_stale_stateid
;
3174 if (STALE_STATEID(stateid
))
3176 status
= nfserr_bad_stateid
;
3177 if (!is_delegation_stateid(stateid
))
3179 dp
= find_delegation_stateid(inode
, stateid
);
3181 status
= stateid_error_map(stateid
);
3184 status
= check_stateid_generation(stateid
, &dp
->dl_stateid
, flags
);
3187 renew_client(dp
->dl_client
);
3189 unhash_delegation(dp
);
3191 nfs4_unlock_state();
3198 * Lock owner state (byte-range locks)
3200 #define LOFF_OVERFLOW(start, len) ((u64)(len) > ~(u64)(start))
3201 #define LOCK_HASH_BITS 8
3202 #define LOCK_HASH_SIZE (1 << LOCK_HASH_BITS)
3203 #define LOCK_HASH_MASK (LOCK_HASH_SIZE - 1)
3206 end_offset(u64 start
, u64 len
)
3211 return end
>= start
? end
: NFS4_MAX_UINT64
;
3214 /* last octet in a range */
3216 last_byte_offset(u64 start
, u64 len
)
3222 return end
> start
? end
- 1: NFS4_MAX_UINT64
;
3225 #define lockownerid_hashval(id) \
3226 ((id) & LOCK_HASH_MASK)
3228 static inline unsigned int
3229 lock_ownerstr_hashval(struct inode
*inode
, u32 cl_id
,
3230 struct xdr_netobj
*ownername
)
3232 return (file_hashval(inode
) + cl_id
3233 + opaque_hashval(ownername
->data
, ownername
->len
))
3237 static struct list_head lock_ownerid_hashtbl
[LOCK_HASH_SIZE
];
3238 static struct list_head lock_ownerstr_hashtbl
[LOCK_HASH_SIZE
];
3239 static struct list_head lockstateid_hashtbl
[STATEID_HASH_SIZE
];
3241 static struct nfs4_stateid
*
3242 find_stateid(stateid_t
*stid
, int flags
)
3244 struct nfs4_stateid
*local
;
3245 u32 st_id
= stid
->si_stateownerid
;
3246 u32 f_id
= stid
->si_fileid
;
3247 unsigned int hashval
;
3249 dprintk("NFSD: find_stateid flags 0x%x\n",flags
);
3250 if (flags
& (LOCK_STATE
| RD_STATE
| WR_STATE
)) {
3251 hashval
= stateid_hashval(st_id
, f_id
);
3252 list_for_each_entry(local
, &lockstateid_hashtbl
[hashval
], st_hash
) {
3253 if ((local
->st_stateid
.si_stateownerid
== st_id
) &&
3254 (local
->st_stateid
.si_fileid
== f_id
))
3259 if (flags
& (OPEN_STATE
| RD_STATE
| WR_STATE
)) {
3260 hashval
= stateid_hashval(st_id
, f_id
);
3261 list_for_each_entry(local
, &stateid_hashtbl
[hashval
], st_hash
) {
3262 if ((local
->st_stateid
.si_stateownerid
== st_id
) &&
3263 (local
->st_stateid
.si_fileid
== f_id
))
3270 static struct nfs4_delegation
*
3271 find_delegation_stateid(struct inode
*ino
, stateid_t
*stid
)
3273 struct nfs4_file
*fp
;
3274 struct nfs4_delegation
*dl
;
3276 dprintk("NFSD: %s: stateid=" STATEID_FMT
"\n", __func__
,
3279 fp
= find_file(ino
);
3282 dl
= find_delegation_file(fp
, stid
);
3288 * TODO: Linux file offsets are _signed_ 64-bit quantities, which means that
3289 * we can't properly handle lock requests that go beyond the (2^63 - 1)-th
3290 * byte, because of sign extension problems. Since NFSv4 calls for 64-bit
3291 * locking, this prevents us from being completely protocol-compliant. The
3292 * real solution to this problem is to start using unsigned file offsets in
3293 * the VFS, but this is a very deep change!
3296 nfs4_transform_lock_offset(struct file_lock
*lock
)
3298 if (lock
->fl_start
< 0)
3299 lock
->fl_start
= OFFSET_MAX
;
3300 if (lock
->fl_end
< 0)
3301 lock
->fl_end
= OFFSET_MAX
;
3304 /* Hack!: For now, we're defining this just so we can use a pointer to it
3305 * as a unique cookie to identify our (NFSv4's) posix locks. */
3306 static const struct lock_manager_operations nfsd_posix_mng_ops
= {
3310 nfs4_set_lock_denied(struct file_lock
*fl
, struct nfsd4_lock_denied
*deny
)
3312 struct nfs4_stateowner
*sop
;
3315 if (fl
->fl_lmops
== &nfsd_posix_mng_ops
) {
3316 sop
= (struct nfs4_stateowner
*) fl
->fl_owner
;
3317 hval
= lockownerid_hashval(sop
->so_id
);
3318 kref_get(&sop
->so_ref
);
3320 deny
->ld_clientid
= sop
->so_client
->cl_clientid
;
3322 deny
->ld_sop
= NULL
;
3323 deny
->ld_clientid
.cl_boot
= 0;
3324 deny
->ld_clientid
.cl_id
= 0;
3326 deny
->ld_start
= fl
->fl_start
;
3327 deny
->ld_length
= NFS4_MAX_UINT64
;
3328 if (fl
->fl_end
!= NFS4_MAX_UINT64
)
3329 deny
->ld_length
= fl
->fl_end
- fl
->fl_start
+ 1;
3330 deny
->ld_type
= NFS4_READ_LT
;
3331 if (fl
->fl_type
!= F_RDLCK
)
3332 deny
->ld_type
= NFS4_WRITE_LT
;
3335 static struct nfs4_stateowner
*
3336 find_lockstateowner_str(struct inode
*inode
, clientid_t
*clid
,
3337 struct xdr_netobj
*owner
)
3339 unsigned int hashval
= lock_ownerstr_hashval(inode
, clid
->cl_id
, owner
);
3340 struct nfs4_stateowner
*op
;
3342 list_for_each_entry(op
, &lock_ownerstr_hashtbl
[hashval
], so_strhash
) {
3343 if (same_owner_str(op
, owner
, clid
))
3350 * Alloc a lock owner structure.
3351 * Called in nfsd4_lock - therefore, OPEN and OPEN_CONFIRM (if needed) has
3354 * strhashval = lock_ownerstr_hashval
3357 static struct nfs4_stateowner
*
3358 alloc_init_lock_stateowner(unsigned int strhashval
, struct nfs4_client
*clp
, struct nfs4_stateid
*open_stp
, struct nfsd4_lock
*lock
) {
3359 struct nfs4_stateowner
*sop
;
3360 struct nfs4_replay
*rp
;
3361 unsigned int idhashval
;
3363 if (!(sop
= alloc_stateowner(&lock
->lk_new_owner
)))
3365 idhashval
= lockownerid_hashval(current_ownerid
);
3366 INIT_LIST_HEAD(&sop
->so_idhash
);
3367 INIT_LIST_HEAD(&sop
->so_strhash
);
3368 INIT_LIST_HEAD(&sop
->so_perclient
);
3369 INIT_LIST_HEAD(&sop
->so_stateids
);
3370 INIT_LIST_HEAD(&sop
->so_perstateid
);
3371 INIT_LIST_HEAD(&sop
->so_close_lru
); /* not used */
3373 list_add(&sop
->so_idhash
, &lock_ownerid_hashtbl
[idhashval
]);
3374 list_add(&sop
->so_strhash
, &lock_ownerstr_hashtbl
[strhashval
]);
3375 list_add(&sop
->so_perstateid
, &open_stp
->st_lockowners
);
3376 sop
->so_is_open_owner
= 0;
3377 sop
->so_id
= current_ownerid
++;
3378 sop
->so_client
= clp
;
3379 /* It is the openowner seqid that will be incremented in encode in the
3380 * case of new lockowners; so increment the lock seqid manually: */
3381 sop
->so_seqid
= lock
->lk_new_lock_seqid
+ 1;
3382 sop
->so_confirmed
= 1;
3383 rp
= &sop
->so_replay
;
3384 rp
->rp_status
= nfserr_serverfault
;
3386 rp
->rp_buf
= rp
->rp_ibuf
;
3390 static struct nfs4_stateid
*
3391 alloc_init_lock_stateid(struct nfs4_stateowner
*sop
, struct nfs4_file
*fp
, struct nfs4_stateid
*open_stp
)
3393 struct nfs4_stateid
*stp
;
3394 unsigned int hashval
= stateid_hashval(sop
->so_id
, fp
->fi_id
);
3396 stp
= nfs4_alloc_stateid();
3399 INIT_LIST_HEAD(&stp
->st_hash
);
3400 INIT_LIST_HEAD(&stp
->st_perfile
);
3401 INIT_LIST_HEAD(&stp
->st_perstateowner
);
3402 INIT_LIST_HEAD(&stp
->st_lockowners
); /* not used */
3403 list_add(&stp
->st_hash
, &lockstateid_hashtbl
[hashval
]);
3404 list_add(&stp
->st_perfile
, &fp
->fi_stateids
);
3405 list_add(&stp
->st_perstateowner
, &sop
->so_stateids
);
3406 stp
->st_stateowner
= sop
;
3409 stp
->st_stateid
.si_boot
= get_seconds();
3410 stp
->st_stateid
.si_stateownerid
= sop
->so_id
;
3411 stp
->st_stateid
.si_fileid
= fp
->fi_id
;
3412 stp
->st_stateid
.si_generation
= 0;
3413 stp
->st_vfs_file
= open_stp
->st_vfs_file
; /* FIXME refcount?? */
3414 stp
->st_access_bmap
= open_stp
->st_access_bmap
;
3415 stp
->st_deny_bmap
= open_stp
->st_deny_bmap
;
3416 stp
->st_openstp
= open_stp
;
3423 check_lock_length(u64 offset
, u64 length
)
3425 return ((length
== 0) || ((length
!= NFS4_MAX_UINT64
) &&
3426 LOFF_OVERFLOW(offset
, length
)));
3433 nfsd4_lock(struct svc_rqst
*rqstp
, struct nfsd4_compound_state
*cstate
,
3434 struct nfsd4_lock
*lock
)
3436 struct nfs4_stateowner
*open_sop
= NULL
;
3437 struct nfs4_stateowner
*lock_sop
= NULL
;
3438 struct nfs4_stateid
*lock_stp
;
3440 struct file_lock file_lock
;
3441 struct file_lock conflock
;
3443 unsigned int strhashval
;
3447 dprintk("NFSD: nfsd4_lock: start=%Ld length=%Ld\n",
3448 (long long) lock
->lk_offset
,
3449 (long long) lock
->lk_length
);
3451 if (check_lock_length(lock
->lk_offset
, lock
->lk_length
))
3452 return nfserr_inval
;
3454 if ((status
= fh_verify(rqstp
, &cstate
->current_fh
,
3455 S_IFREG
, NFSD_MAY_LOCK
))) {
3456 dprintk("NFSD: nfsd4_lock: permission denied!\n");
3462 if (lock
->lk_is_new
) {
3464 * Client indicates that this is a new lockowner.
3465 * Use open owner and open stateid to create lock owner and
3468 struct nfs4_stateid
*open_stp
= NULL
;
3469 struct nfs4_file
*fp
;
3471 status
= nfserr_stale_clientid
;
3472 if (!nfsd4_has_session(cstate
) &&
3473 STALE_CLIENTID(&lock
->lk_new_clientid
))
3476 /* validate and update open stateid and open seqid */
3477 status
= nfs4_preprocess_seqid_op(cstate
,
3478 lock
->lk_new_open_seqid
,
3479 &lock
->lk_new_open_stateid
,
3481 &lock
->lk_replay_owner
, &open_stp
,
3485 open_sop
= lock
->lk_replay_owner
;
3486 /* create lockowner and lock stateid */
3487 fp
= open_stp
->st_file
;
3488 strhashval
= lock_ownerstr_hashval(fp
->fi_inode
,
3489 open_sop
->so_client
->cl_clientid
.cl_id
,
3490 &lock
->v
.new.owner
);
3491 /* XXX: Do we need to check for duplicate stateowners on
3492 * the same file, or should they just be allowed (and
3493 * create new stateids)? */
3494 status
= nfserr_resource
;
3495 lock_sop
= alloc_init_lock_stateowner(strhashval
,
3496 open_sop
->so_client
, open_stp
, lock
);
3497 if (lock_sop
== NULL
)
3499 lock_stp
= alloc_init_lock_stateid(lock_sop
, fp
, open_stp
);
3500 if (lock_stp
== NULL
)
3503 /* lock (lock owner + lock stateid) already exists */
3504 status
= nfs4_preprocess_seqid_op(cstate
,
3505 lock
->lk_old_lock_seqid
,
3506 &lock
->lk_old_lock_stateid
,
3508 &lock
->lk_replay_owner
, &lock_stp
, lock
);
3511 lock_sop
= lock
->lk_replay_owner
;
3513 /* lock->lk_replay_owner and lock_stp have been created or found */
3514 filp
= lock_stp
->st_vfs_file
;
3516 status
= nfserr_grace
;
3517 if (locks_in_grace() && !lock
->lk_reclaim
)
3519 status
= nfserr_no_grace
;
3520 if (!locks_in_grace() && lock
->lk_reclaim
)
3523 locks_init_lock(&file_lock
);
3524 switch (lock
->lk_type
) {
3527 file_lock
.fl_type
= F_RDLCK
;
3531 case NFS4_WRITEW_LT
:
3532 file_lock
.fl_type
= F_WRLCK
;
3536 status
= nfserr_inval
;
3539 file_lock
.fl_owner
= (fl_owner_t
)lock_sop
;
3540 file_lock
.fl_pid
= current
->tgid
;
3541 file_lock
.fl_file
= filp
;
3542 file_lock
.fl_flags
= FL_POSIX
;
3543 file_lock
.fl_lmops
= &nfsd_posix_mng_ops
;
3545 file_lock
.fl_start
= lock
->lk_offset
;
3546 file_lock
.fl_end
= last_byte_offset(lock
->lk_offset
, lock
->lk_length
);
3547 nfs4_transform_lock_offset(&file_lock
);
3550 * Try to lock the file in the VFS.
3551 * Note: locks.c uses the BKL to protect the inode's lock list.
3554 err
= vfs_lock_file(filp
, cmd
, &file_lock
, &conflock
);
3556 case 0: /* success! */
3557 update_stateid(&lock_stp
->st_stateid
);
3558 memcpy(&lock
->lk_resp_stateid
, &lock_stp
->st_stateid
,
3562 case (EAGAIN
): /* conflock holds conflicting lock */
3563 status
= nfserr_denied
;
3564 dprintk("NFSD: nfsd4_lock: conflicting lock found!\n");
3565 nfs4_set_lock_denied(&conflock
, &lock
->lk_denied
);
3568 status
= nfserr_deadlock
;
3571 dprintk("NFSD: nfsd4_lock: vfs_lock_file() failed! status %d\n",err
);
3572 status
= nfserr_resource
;
3576 if (status
&& lock
->lk_is_new
&& lock_sop
)
3577 release_lockowner(lock_sop
);
3578 if (lock
->lk_replay_owner
) {
3579 nfs4_get_stateowner(lock
->lk_replay_owner
);
3580 cstate
->replay_owner
= lock
->lk_replay_owner
;
3582 nfs4_unlock_state();
3587 * The NFSv4 spec allows a client to do a LOCKT without holding an OPEN,
3588 * so we do a temporary open here just to get an open file to pass to
3589 * vfs_test_lock. (Arguably perhaps test_lock should be done with an
3592 static int nfsd_test_lock(struct svc_rqst
*rqstp
, struct svc_fh
*fhp
, struct file_lock
*lock
)
3597 err
= nfsd_open(rqstp
, fhp
, S_IFREG
, NFSD_MAY_READ
, &file
);
3600 err
= vfs_test_lock(file
, lock
);
3609 nfsd4_lockt(struct svc_rqst
*rqstp
, struct nfsd4_compound_state
*cstate
,
3610 struct nfsd4_lockt
*lockt
)
3612 struct inode
*inode
;
3613 struct file_lock file_lock
;
3617 if (locks_in_grace())
3618 return nfserr_grace
;
3620 if (check_lock_length(lockt
->lt_offset
, lockt
->lt_length
))
3621 return nfserr_inval
;
3623 lockt
->lt_stateowner
= NULL
;
3626 status
= nfserr_stale_clientid
;
3627 if (!nfsd4_has_session(cstate
) && STALE_CLIENTID(&lockt
->lt_clientid
))
3630 if ((status
= fh_verify(rqstp
, &cstate
->current_fh
, S_IFREG
, 0))) {
3631 dprintk("NFSD: nfsd4_lockt: fh_verify() failed!\n");
3632 if (status
== nfserr_symlink
)
3633 status
= nfserr_inval
;
3637 inode
= cstate
->current_fh
.fh_dentry
->d_inode
;
3638 locks_init_lock(&file_lock
);
3639 switch (lockt
->lt_type
) {
3642 file_lock
.fl_type
= F_RDLCK
;
3645 case NFS4_WRITEW_LT
:
3646 file_lock
.fl_type
= F_WRLCK
;
3649 dprintk("NFSD: nfs4_lockt: bad lock type!\n");
3650 status
= nfserr_inval
;
3654 lockt
->lt_stateowner
= find_lockstateowner_str(inode
,
3655 &lockt
->lt_clientid
, &lockt
->lt_owner
);
3656 if (lockt
->lt_stateowner
)
3657 file_lock
.fl_owner
= (fl_owner_t
)lockt
->lt_stateowner
;
3658 file_lock
.fl_pid
= current
->tgid
;
3659 file_lock
.fl_flags
= FL_POSIX
;
3661 file_lock
.fl_start
= lockt
->lt_offset
;
3662 file_lock
.fl_end
= last_byte_offset(lockt
->lt_offset
, lockt
->lt_length
);
3664 nfs4_transform_lock_offset(&file_lock
);
3667 error
= nfsd_test_lock(rqstp
, &cstate
->current_fh
, &file_lock
);
3669 status
= nfserrno(error
);
3672 if (file_lock
.fl_type
!= F_UNLCK
) {
3673 status
= nfserr_denied
;
3674 nfs4_set_lock_denied(&file_lock
, &lockt
->lt_denied
);
3677 nfs4_unlock_state();
3682 nfsd4_locku(struct svc_rqst
*rqstp
, struct nfsd4_compound_state
*cstate
,
3683 struct nfsd4_locku
*locku
)
3685 struct nfs4_stateid
*stp
;
3686 struct file
*filp
= NULL
;
3687 struct file_lock file_lock
;
3691 dprintk("NFSD: nfsd4_locku: start=%Ld length=%Ld\n",
3692 (long long) locku
->lu_offset
,
3693 (long long) locku
->lu_length
);
3695 if (check_lock_length(locku
->lu_offset
, locku
->lu_length
))
3696 return nfserr_inval
;
3700 if ((status
= nfs4_preprocess_seqid_op(cstate
,
3704 &locku
->lu_stateowner
, &stp
, NULL
)))
3707 filp
= stp
->st_vfs_file
;
3709 locks_init_lock(&file_lock
);
3710 file_lock
.fl_type
= F_UNLCK
;
3711 file_lock
.fl_owner
= (fl_owner_t
) locku
->lu_stateowner
;
3712 file_lock
.fl_pid
= current
->tgid
;
3713 file_lock
.fl_file
= filp
;
3714 file_lock
.fl_flags
= FL_POSIX
;
3715 file_lock
.fl_lmops
= &nfsd_posix_mng_ops
;
3716 file_lock
.fl_start
= locku
->lu_offset
;
3718 file_lock
.fl_end
= last_byte_offset(locku
->lu_offset
, locku
->lu_length
);
3719 nfs4_transform_lock_offset(&file_lock
);
3722 * Try to unlock the file in the VFS.
3724 err
= vfs_lock_file(filp
, F_SETLK
, &file_lock
, NULL
);
3726 dprintk("NFSD: nfs4_locku: vfs_lock_file failed!\n");
3730 * OK, unlock succeeded; the only thing left to do is update the stateid.
3732 update_stateid(&stp
->st_stateid
);
3733 memcpy(&locku
->lu_stateid
, &stp
->st_stateid
, sizeof(stateid_t
));
3736 if (locku
->lu_stateowner
) {
3737 nfs4_get_stateowner(locku
->lu_stateowner
);
3738 cstate
->replay_owner
= locku
->lu_stateowner
;
3740 nfs4_unlock_state();
3744 status
= nfserrno(err
);
3750 * 1: locks held by lockowner
3751 * 0: no locks held by lockowner
3754 check_for_locks(struct file
*filp
, struct nfs4_stateowner
*lowner
)
3756 struct file_lock
**flpp
;
3757 struct inode
*inode
= filp
->f_path
.dentry
->d_inode
;
3761 for (flpp
= &inode
->i_flock
; *flpp
!= NULL
; flpp
= &(*flpp
)->fl_next
) {
3762 if ((*flpp
)->fl_owner
== (fl_owner_t
)lowner
) {
3773 nfsd4_release_lockowner(struct svc_rqst
*rqstp
,
3774 struct nfsd4_compound_state
*cstate
,
3775 struct nfsd4_release_lockowner
*rlockowner
)
3777 clientid_t
*clid
= &rlockowner
->rl_clientid
;
3778 struct nfs4_stateowner
*sop
;
3779 struct nfs4_stateid
*stp
;
3780 struct xdr_netobj
*owner
= &rlockowner
->rl_owner
;
3781 struct list_head matches
;
3785 dprintk("nfsd4_release_lockowner clientid: (%08x/%08x):\n",
3786 clid
->cl_boot
, clid
->cl_id
);
3788 /* XXX check for lease expiration */
3790 status
= nfserr_stale_clientid
;
3791 if (STALE_CLIENTID(clid
))
3796 status
= nfserr_locks_held
;
3797 /* XXX: we're doing a linear search through all the lockowners.
3798 * Yipes! For now we'll just hope clients aren't really using
3799 * release_lockowner much, but eventually we have to fix these
3800 * data structures. */
3801 INIT_LIST_HEAD(&matches
);
3802 for (i
= 0; i
< LOCK_HASH_SIZE
; i
++) {
3803 list_for_each_entry(sop
, &lock_ownerid_hashtbl
[i
], so_idhash
) {
3804 if (!same_owner_str(sop
, owner
, clid
))
3806 list_for_each_entry(stp
, &sop
->so_stateids
,
3808 if (check_for_locks(stp
->st_vfs_file
, sop
))
3810 /* Note: so_perclient unused for lockowners,
3811 * so it's OK to fool with here. */
3812 list_add(&sop
->so_perclient
, &matches
);
3816 /* Clients probably won't expect us to return with some (but not all)
3817 * of the lockowner state released; so don't release any until all
3818 * have been checked. */
3820 while (!list_empty(&matches
)) {
3821 sop
= list_entry(matches
.next
, struct nfs4_stateowner
,
3823 /* unhash_stateowner deletes so_perclient only
3824 * for openowners. */
3825 list_del(&sop
->so_perclient
);
3826 release_lockowner(sop
);
3829 nfs4_unlock_state();
3833 static inline struct nfs4_client_reclaim
*
3836 return kmalloc(sizeof(struct nfs4_client_reclaim
), GFP_KERNEL
);
3840 nfs4_has_reclaimed_state(const char *name
, bool use_exchange_id
)
3842 unsigned int strhashval
= clientstr_hashval(name
);
3843 struct nfs4_client
*clp
;
3845 clp
= find_confirmed_client_by_str(name
, strhashval
, use_exchange_id
);
3850 * failure => all reset bets are off, nfserr_no_grace...
3853 nfs4_client_to_reclaim(const char *name
)
3855 unsigned int strhashval
;
3856 struct nfs4_client_reclaim
*crp
= NULL
;
3858 dprintk("NFSD nfs4_client_to_reclaim NAME: %.*s\n", HEXDIR_LEN
, name
);
3859 crp
= alloc_reclaim();
3862 strhashval
= clientstr_hashval(name
);
3863 INIT_LIST_HEAD(&crp
->cr_strhash
);
3864 list_add(&crp
->cr_strhash
, &reclaim_str_hashtbl
[strhashval
]);
3865 memcpy(crp
->cr_recdir
, name
, HEXDIR_LEN
);
3866 reclaim_str_hashtbl_size
++;
3871 nfs4_release_reclaim(void)
3873 struct nfs4_client_reclaim
*crp
= NULL
;
3876 for (i
= 0; i
< CLIENT_HASH_SIZE
; i
++) {
3877 while (!list_empty(&reclaim_str_hashtbl
[i
])) {
3878 crp
= list_entry(reclaim_str_hashtbl
[i
].next
,
3879 struct nfs4_client_reclaim
, cr_strhash
);
3880 list_del(&crp
->cr_strhash
);
3882 reclaim_str_hashtbl_size
--;
3885 BUG_ON(reclaim_str_hashtbl_size
);
3889 * called from OPEN, CLAIM_PREVIOUS with a new clientid. */
3890 static struct nfs4_client_reclaim
*
3891 nfs4_find_reclaim_client(clientid_t
*clid
)
3893 unsigned int strhashval
;
3894 struct nfs4_client
*clp
;
3895 struct nfs4_client_reclaim
*crp
= NULL
;
3898 /* find clientid in conf_id_hashtbl */
3899 clp
= find_confirmed_client(clid
);
3903 dprintk("NFSD: nfs4_find_reclaim_client for %.*s with recdir %s\n",
3904 clp
->cl_name
.len
, clp
->cl_name
.data
,
3907 /* find clp->cl_name in reclaim_str_hashtbl */
3908 strhashval
= clientstr_hashval(clp
->cl_recdir
);
3909 list_for_each_entry(crp
, &reclaim_str_hashtbl
[strhashval
], cr_strhash
) {
3910 if (same_name(crp
->cr_recdir
, clp
->cl_recdir
)) {
3918 * Called from OPEN. Look for clientid in reclaim list.
3921 nfs4_check_open_reclaim(clientid_t
*clid
)
3923 return nfs4_find_reclaim_client(clid
) ? nfs_ok
: nfserr_reclaim_bad
;
3926 /* initialization to perform at module load time: */
3929 nfs4_state_init(void)
3933 status
= nfsd4_init_slabs();
3936 for (i
= 0; i
< CLIENT_HASH_SIZE
; i
++) {
3937 INIT_LIST_HEAD(&conf_id_hashtbl
[i
]);
3938 INIT_LIST_HEAD(&conf_str_hashtbl
[i
]);
3939 INIT_LIST_HEAD(&unconf_str_hashtbl
[i
]);
3940 INIT_LIST_HEAD(&unconf_id_hashtbl
[i
]);
3941 INIT_LIST_HEAD(&reclaim_str_hashtbl
[i
]);
3943 for (i
= 0; i
< SESSION_HASH_SIZE
; i
++)
3944 INIT_LIST_HEAD(&sessionid_hashtbl
[i
]);
3945 for (i
= 0; i
< FILE_HASH_SIZE
; i
++) {
3946 INIT_LIST_HEAD(&file_hashtbl
[i
]);
3948 for (i
= 0; i
< OWNER_HASH_SIZE
; i
++) {
3949 INIT_LIST_HEAD(&ownerstr_hashtbl
[i
]);
3950 INIT_LIST_HEAD(&ownerid_hashtbl
[i
]);
3952 for (i
= 0; i
< STATEID_HASH_SIZE
; i
++) {
3953 INIT_LIST_HEAD(&stateid_hashtbl
[i
]);
3954 INIT_LIST_HEAD(&lockstateid_hashtbl
[i
]);
3956 for (i
= 0; i
< LOCK_HASH_SIZE
; i
++) {
3957 INIT_LIST_HEAD(&lock_ownerid_hashtbl
[i
]);
3958 INIT_LIST_HEAD(&lock_ownerstr_hashtbl
[i
]);
3960 memset(&onestateid
, ~0, sizeof(stateid_t
));
3961 INIT_LIST_HEAD(&close_lru
);
3962 INIT_LIST_HEAD(&client_lru
);
3963 INIT_LIST_HEAD(&del_recall_lru
);
3964 reclaim_str_hashtbl_size
= 0;
3969 nfsd4_load_reboot_recovery_data(void)
3974 nfsd4_init_recdir(user_recovery_dirname
);
3975 status
= nfsd4_recdir_load();
3976 nfs4_unlock_state();
3978 printk("NFSD: Failure reading reboot recovery data\n");
3982 * Since the lifetime of a delegation isn't limited to that of an open, a
3983 * client may quite reasonably hang on to a delegation as long as it has
3984 * the inode cached. This becomes an obvious problem the first time a
3985 * client's inode cache approaches the size of the server's total memory.
3987 * For now we avoid this problem by imposing a hard limit on the number
3988 * of delegations, which varies according to the server's memory size.
3991 set_max_delegations(void)
3994 * Allow at most 4 delegations per megabyte of RAM. Quick
3995 * estimates suggest that in the worst case (where every delegation
3996 * is for a different inode), a delegation could take about 1.5K,
3997 * giving a worst case usage of about 6% of memory.
3999 max_delegations
= nr_free_buffer_pages() >> (20 - 2 - PAGE_SHIFT
);
4002 /* initialization to perform when the nfsd service is started: */
4005 __nfs4_state_start(void)
4007 boot_time
= get_seconds();
4008 locks_start_grace(&nfsd4_manager
);
4009 printk(KERN_INFO
"NFSD: starting %ld-second grace period\n",
4011 laundry_wq
= create_singlethread_workqueue("nfsd4");
4012 if (laundry_wq
== NULL
)
4014 queue_delayed_work(laundry_wq
, &laundromat_work
, nfsd4_grace
* HZ
);
4015 set_max_delegations();
4016 return set_callback_cred();
4020 nfs4_state_start(void)
4026 nfsd4_load_reboot_recovery_data();
4027 ret
= __nfs4_state_start();
4035 __nfs4_state_shutdown(void)
4038 struct nfs4_client
*clp
= NULL
;
4039 struct nfs4_delegation
*dp
= NULL
;
4040 struct list_head
*pos
, *next
, reaplist
;
4042 for (i
= 0; i
< CLIENT_HASH_SIZE
; i
++) {
4043 while (!list_empty(&conf_id_hashtbl
[i
])) {
4044 clp
= list_entry(conf_id_hashtbl
[i
].next
, struct nfs4_client
, cl_idhash
);
4047 while (!list_empty(&unconf_str_hashtbl
[i
])) {
4048 clp
= list_entry(unconf_str_hashtbl
[i
].next
, struct nfs4_client
, cl_strhash
);
4052 INIT_LIST_HEAD(&reaplist
);
4053 spin_lock(&recall_lock
);
4054 list_for_each_safe(pos
, next
, &del_recall_lru
) {
4055 dp
= list_entry (pos
, struct nfs4_delegation
, dl_recall_lru
);
4056 list_move(&dp
->dl_recall_lru
, &reaplist
);
4058 spin_unlock(&recall_lock
);
4059 list_for_each_safe(pos
, next
, &reaplist
) {
4060 dp
= list_entry (pos
, struct nfs4_delegation
, dl_recall_lru
);
4061 list_del_init(&dp
->dl_recall_lru
);
4062 unhash_delegation(dp
);
4065 nfsd4_shutdown_recdir();
4070 nfs4_state_shutdown(void)
4072 cancel_rearming_delayed_workqueue(laundry_wq
, &laundromat_work
);
4073 destroy_workqueue(laundry_wq
);
4074 locks_end_grace(&nfsd4_manager
);
4076 nfs4_release_reclaim();
4077 __nfs4_state_shutdown();
4078 nfs4_unlock_state();
4082 * user_recovery_dirname is protected by the nfsd_mutex since it's only
4083 * accessed when nfsd is starting.
4086 nfs4_set_recdir(char *recdir
)
4088 strcpy(user_recovery_dirname
, recdir
);
4092 * Change the NFSv4 recovery directory to recdir.
4095 nfs4_reset_recoverydir(char *recdir
)
4100 status
= kern_path(recdir
, LOOKUP_FOLLOW
, &path
);
4104 if (S_ISDIR(path
.dentry
->d_inode
->i_mode
)) {
4105 nfs4_set_recdir(recdir
);
4113 nfs4_recoverydir(void)
4115 return user_recovery_dirname
;