2 * linux/fs/nfs/callback_proc.c
4 * Copyright (C) 2004 Trond Myklebust
6 * NFSv4 callback procedures
8 #include <linux/nfs4.h>
9 #include <linux/nfs_fs.h>
10 #include <linux/slab.h>
11 #include <linux/rcupdate.h>
14 #include "delegation.h"
17 #include "nfs4session.h"
18 #include "nfs4trace.h"
20 #define NFSDBG_FACILITY NFSDBG_CALLBACK
22 __be32
nfs4_callback_getattr(struct cb_getattrargs
*args
,
23 struct cb_getattrres
*res
,
24 struct cb_process_state
*cps
)
26 struct nfs_delegation
*delegation
;
27 struct nfs_inode
*nfsi
;
30 res
->status
= htonl(NFS4ERR_OP_NOT_IN_SESSION
);
31 if (!cps
->clp
) /* Always set for v4.0. Set in cb_sequence for v4.1 */
34 res
->bitmap
[0] = res
->bitmap
[1] = 0;
35 res
->status
= htonl(NFS4ERR_BADHANDLE
);
37 dprintk_rcu("NFS: GETATTR callback request from %s\n",
38 rpc_peeraddr2str(cps
->clp
->cl_rpcclient
, RPC_DISPLAY_ADDR
));
40 inode
= nfs_delegation_find_inode(cps
->clp
, &args
->fh
);
42 trace_nfs4_cb_getattr(cps
->clp
, &args
->fh
, NULL
,
48 delegation
= rcu_dereference(nfsi
->delegation
);
49 if (delegation
== NULL
|| (delegation
->type
& FMODE_WRITE
) == 0)
51 res
->size
= i_size_read(inode
);
52 res
->change_attr
= delegation
->change_attr
;
53 if (nfsi
->nrequests
!= 0)
55 res
->ctime
= inode
->i_ctime
;
56 res
->mtime
= inode
->i_mtime
;
57 res
->bitmap
[0] = (FATTR4_WORD0_CHANGE
|FATTR4_WORD0_SIZE
) &
59 res
->bitmap
[1] = (FATTR4_WORD1_TIME_METADATA
|FATTR4_WORD1_TIME_MODIFY
) &
64 trace_nfs4_cb_getattr(cps
->clp
, &args
->fh
, inode
, -ntohl(res
->status
));
67 dprintk("%s: exit with status = %d\n", __func__
, ntohl(res
->status
));
71 __be32
nfs4_callback_recall(struct cb_recallargs
*args
, void *dummy
,
72 struct cb_process_state
*cps
)
77 res
= htonl(NFS4ERR_OP_NOT_IN_SESSION
);
78 if (!cps
->clp
) /* Always set for v4.0. Set in cb_sequence for v4.1 */
81 dprintk_rcu("NFS: RECALL callback request from %s\n",
82 rpc_peeraddr2str(cps
->clp
->cl_rpcclient
, RPC_DISPLAY_ADDR
));
84 res
= htonl(NFS4ERR_BADHANDLE
);
85 inode
= nfs_delegation_find_inode(cps
->clp
, &args
->fh
);
87 trace_nfs4_cb_recall(cps
->clp
, &args
->fh
, NULL
,
88 &args
->stateid
, -ntohl(res
));
91 /* Set up a helper thread to actually return the delegation */
92 switch (nfs_async_inode_return_delegation(inode
, &args
->stateid
)) {
97 res
= htonl(NFS4ERR_BAD_STATEID
);
100 res
= htonl(NFS4ERR_RESOURCE
);
102 trace_nfs4_cb_recall(cps
->clp
, &args
->fh
, inode
,
103 &args
->stateid
, -ntohl(res
));
106 dprintk("%s: exit with status = %d\n", __func__
, ntohl(res
));
110 #if defined(CONFIG_NFS_V4_1)
113 * Lookup a layout inode by stateid
115 * Note: returns a refcount on the inode and superblock
117 static struct inode
*nfs_layout_find_inode_by_stateid(struct nfs_client
*clp
,
118 const nfs4_stateid
*stateid
)
120 struct nfs_server
*server
;
122 struct pnfs_layout_hdr
*lo
;
125 list_for_each_entry_rcu(server
, &clp
->cl_superblocks
, client_link
) {
126 list_for_each_entry(lo
, &server
->layouts
, plh_layouts
) {
127 if (stateid
!= NULL
&&
128 !nfs4_stateid_match_other(stateid
, &lo
->plh_stateid
))
130 inode
= igrab(lo
->plh_inode
);
133 if (!nfs_sb_active(inode
->i_sb
)) {
135 spin_unlock(&clp
->cl_lock
);
137 spin_lock(&clp
->cl_lock
);
149 * Lookup a layout inode by filehandle.
151 * Note: returns a refcount on the inode and superblock
154 static struct inode
*nfs_layout_find_inode_by_fh(struct nfs_client
*clp
,
155 const struct nfs_fh
*fh
)
157 struct nfs_server
*server
;
158 struct nfs_inode
*nfsi
;
160 struct pnfs_layout_hdr
*lo
;
163 list_for_each_entry_rcu(server
, &clp
->cl_superblocks
, client_link
) {
164 list_for_each_entry(lo
, &server
->layouts
, plh_layouts
) {
165 nfsi
= NFS_I(lo
->plh_inode
);
166 if (nfs_compare_fh(fh
, &nfsi
->fh
))
168 if (nfsi
->layout
!= lo
)
170 inode
= igrab(lo
->plh_inode
);
173 if (!nfs_sb_active(inode
->i_sb
)) {
175 spin_unlock(&clp
->cl_lock
);
177 spin_lock(&clp
->cl_lock
);
188 static struct inode
*nfs_layout_find_inode(struct nfs_client
*clp
,
189 const struct nfs_fh
*fh
,
190 const nfs4_stateid
*stateid
)
194 spin_lock(&clp
->cl_lock
);
196 inode
= nfs_layout_find_inode_by_stateid(clp
, stateid
);
198 inode
= nfs_layout_find_inode_by_fh(clp
, fh
);
200 spin_unlock(&clp
->cl_lock
);
206 * Enforce RFC5661 section 12.5.5.2.1. (Layout Recall and Return Sequencing)
208 static u32
pnfs_check_callback_stateid(struct pnfs_layout_hdr
*lo
,
209 const nfs4_stateid
*new)
213 /* Is the stateid still not initialised? */
214 if (!pnfs_layout_is_valid(lo
))
215 return NFS4ERR_DELAY
;
217 /* Mismatched stateid? */
218 if (!nfs4_stateid_match_other(&lo
->plh_stateid
, new))
219 return NFS4ERR_BAD_STATEID
;
221 newseq
= be32_to_cpu(new->seqid
);
222 /* Are we already in a layout recall situation? */
223 if (test_bit(NFS_LAYOUT_RETURN_REQUESTED
, &lo
->plh_flags
) &&
224 lo
->plh_return_seq
!= 0) {
225 if (newseq
< lo
->plh_return_seq
)
226 return NFS4ERR_OLD_STATEID
;
227 if (newseq
> lo
->plh_return_seq
)
228 return NFS4ERR_DELAY
;
232 /* Check that the stateid matches what we think it should be. */
233 oldseq
= be32_to_cpu(lo
->plh_stateid
.seqid
);
234 if (newseq
> oldseq
+ 1)
235 return NFS4ERR_DELAY
;
237 if (newseq
<= oldseq
)
238 return NFS4ERR_OLD_STATEID
;
243 static u32
initiate_file_draining(struct nfs_client
*clp
,
244 struct cb_layoutrecallargs
*args
)
247 struct pnfs_layout_hdr
*lo
;
248 u32 rv
= NFS4ERR_NOMATCHING_LAYOUT
;
249 LIST_HEAD(free_me_list
);
251 ino
= nfs_layout_find_inode(clp
, &args
->cbl_fh
, &args
->cbl_stateid
);
255 pnfs_layoutcommit_inode(ino
, false);
258 spin_lock(&ino
->i_lock
);
259 lo
= NFS_I(ino
)->layout
;
261 spin_unlock(&ino
->i_lock
);
264 pnfs_get_layout_hdr(lo
);
265 rv
= pnfs_check_callback_stateid(lo
, &args
->cbl_stateid
);
268 pnfs_set_layout_stateid(lo
, &args
->cbl_stateid
, true);
271 * Enforce RFC5661 Section 12.5.5.2.1.5 (Bulk Recall and Return)
273 if (test_bit(NFS_LAYOUT_BULK_RECALL
, &lo
->plh_flags
)) {
278 if (pnfs_mark_matching_lsegs_return(lo
, &free_me_list
,
280 be32_to_cpu(args
->cbl_stateid
.seqid
))) {
285 /* Embrace your forgetfulness! */
286 rv
= NFS4ERR_NOMATCHING_LAYOUT
;
288 if (NFS_SERVER(ino
)->pnfs_curr_ld
->return_range
) {
289 NFS_SERVER(ino
)->pnfs_curr_ld
->return_range(lo
,
293 spin_unlock(&ino
->i_lock
);
294 pnfs_free_lseg_list(&free_me_list
);
295 /* Free all lsegs that are attached to commit buckets */
296 nfs_commit_inode(ino
, 0);
297 pnfs_put_layout_hdr(lo
);
299 trace_nfs4_cb_layoutrecall_file(clp
, &args
->cbl_fh
, ino
,
300 &args
->cbl_stateid
, -rv
);
301 nfs_iput_and_deactive(ino
);
305 static u32
initiate_bulk_draining(struct nfs_client
*clp
,
306 struct cb_layoutrecallargs
*args
)
310 if (args
->cbl_recall_type
== RETURN_FSID
)
311 stat
= pnfs_destroy_layouts_byfsid(clp
, &args
->cbl_fsid
, true);
313 stat
= pnfs_destroy_layouts_byclid(clp
, true);
315 return NFS4ERR_DELAY
;
316 return NFS4ERR_NOMATCHING_LAYOUT
;
319 static u32
do_callback_layoutrecall(struct nfs_client
*clp
,
320 struct cb_layoutrecallargs
*args
)
322 if (args
->cbl_recall_type
== RETURN_FILE
)
323 return initiate_file_draining(clp
, args
);
324 return initiate_bulk_draining(clp
, args
);
327 __be32
nfs4_callback_layoutrecall(struct cb_layoutrecallargs
*args
,
328 void *dummy
, struct cb_process_state
*cps
)
330 u32 res
= NFS4ERR_OP_NOT_IN_SESSION
;
333 res
= do_callback_layoutrecall(cps
->clp
, args
);
334 return cpu_to_be32(res
);
337 static void pnfs_recall_all_layouts(struct nfs_client
*clp
)
339 struct cb_layoutrecallargs args
;
341 /* Pretend we got a CB_LAYOUTRECALL(ALL) */
342 memset(&args
, 0, sizeof(args
));
343 args
.cbl_recall_type
= RETURN_ALL
;
344 /* FIXME we ignore errors, what should we do? */
345 do_callback_layoutrecall(clp
, &args
);
348 __be32
nfs4_callback_devicenotify(struct cb_devicenotifyargs
*args
,
349 void *dummy
, struct cb_process_state
*cps
)
353 struct nfs_client
*clp
= cps
->clp
;
354 struct nfs_server
*server
= NULL
;
357 res
= cpu_to_be32(NFS4ERR_OP_NOT_IN_SESSION
);
361 for (i
= 0; i
< args
->ndevs
; i
++) {
362 struct cb_devicenotifyitem
*dev
= &args
->devs
[i
];
365 server
->pnfs_curr_ld
->id
!= dev
->cbd_layout_type
) {
367 list_for_each_entry_rcu(server
, &clp
->cl_superblocks
, client_link
)
368 if (server
->pnfs_curr_ld
&&
369 server
->pnfs_curr_ld
->id
== dev
->cbd_layout_type
) {
378 nfs4_delete_deviceid(server
->pnfs_curr_ld
, clp
, &dev
->cbd_dev_id
);
387 * Validate the sequenceID sent by the server.
388 * Return success if the sequenceID is one more than what we last saw on
389 * this slot, accounting for wraparound. Increments the slot's sequence.
391 * We don't yet implement a duplicate request cache, instead we set the
392 * back channel ca_maxresponsesize_cached to zero. This is OK for now
393 * since we only currently implement idempotent callbacks anyway.
395 * We have a single slot backchannel at this time, so we don't bother
396 * checking the used_slots bit array on the table. The lower layer guarantees
397 * a single outstanding callback request at a time.
400 validate_seqid(const struct nfs4_slot_table
*tbl
, const struct nfs4_slot
*slot
,
401 const struct cb_sequenceargs
* args
)
403 if (args
->csa_slotid
> tbl
->server_highest_slotid
)
404 return htonl(NFS4ERR_BADSLOT
);
407 if (args
->csa_sequenceid
== slot
->seq_nr
) {
408 if (nfs4_test_locked_slot(tbl
, slot
->slot_nr
))
409 return htonl(NFS4ERR_DELAY
);
410 /* Signal process_op to set this error on next op */
411 if (args
->csa_cachethis
== 0)
412 return htonl(NFS4ERR_RETRY_UNCACHED_REP
);
414 /* Liar! We never allowed you to set csa_cachethis != 0 */
415 return htonl(NFS4ERR_SEQ_FALSE_RETRY
);
419 if (unlikely(slot
->seq_nr
== 0xFFFFFFFFU
)) {
420 if (args
->csa_sequenceid
== 1)
421 return htonl(NFS4_OK
);
422 } else if (likely(args
->csa_sequenceid
== slot
->seq_nr
+ 1))
423 return htonl(NFS4_OK
);
425 /* Misordered request */
426 return htonl(NFS4ERR_SEQ_MISORDERED
);
430 * For each referring call triple, check the session's slot table for
431 * a match. If the slot is in use and the sequence numbers match, the
432 * client is still waiting for a response to the original request.
434 static bool referring_call_exists(struct nfs_client
*clp
,
436 struct referring_call_list
*rclists
)
440 struct nfs4_session
*session
;
441 struct nfs4_slot_table
*tbl
;
442 struct referring_call_list
*rclist
;
443 struct referring_call
*ref
;
446 * XXX When client trunking is implemented, this becomes
447 * a session lookup from within the loop
449 session
= clp
->cl_session
;
450 tbl
= &session
->fc_slot_table
;
452 for (i
= 0; i
< nrclists
; i
++) {
453 rclist
= &rclists
[i
];
454 if (memcmp(session
->sess_id
.data
,
455 rclist
->rcl_sessionid
.data
,
456 NFS4_MAX_SESSIONID_LEN
) != 0)
459 for (j
= 0; j
< rclist
->rcl_nrefcalls
; j
++) {
460 ref
= &rclist
->rcl_refcalls
[j
];
461 status
= nfs4_slot_wait_on_seqid(tbl
, ref
->rc_slotid
,
462 ref
->rc_sequenceid
, HZ
>> 1) < 0;
472 __be32
nfs4_callback_sequence(struct cb_sequenceargs
*args
,
473 struct cb_sequenceres
*res
,
474 struct cb_process_state
*cps
)
476 struct nfs4_slot_table
*tbl
;
477 struct nfs4_slot
*slot
;
478 struct nfs_client
*clp
;
480 __be32 status
= htonl(NFS4ERR_BADSESSION
);
482 clp
= nfs4_find_client_sessionid(cps
->net
, args
->csa_addr
,
483 &args
->csa_sessionid
, cps
->minorversion
);
487 if (!(clp
->cl_session
->flags
& SESSION4_BACK_CHAN
))
490 tbl
= &clp
->cl_session
->bc_slot_table
;
492 /* Set up res before grabbing the spinlock */
493 memcpy(&res
->csr_sessionid
, &args
->csa_sessionid
,
494 sizeof(res
->csr_sessionid
));
495 res
->csr_sequenceid
= args
->csa_sequenceid
;
496 res
->csr_slotid
= args
->csa_slotid
;
498 spin_lock(&tbl
->slot_tbl_lock
);
499 /* state manager is resetting the session */
500 if (test_bit(NFS4_SLOT_TBL_DRAINING
, &tbl
->slot_tbl_state
)) {
501 status
= htonl(NFS4ERR_DELAY
);
502 /* Return NFS4ERR_BADSESSION if we're draining the session
503 * in order to reset it.
505 if (test_bit(NFS4CLNT_SESSION_RESET
, &clp
->cl_state
))
506 status
= htonl(NFS4ERR_BADSESSION
);
510 status
= htonl(NFS4ERR_BADSLOT
);
511 slot
= nfs4_lookup_slot(tbl
, args
->csa_slotid
);
515 res
->csr_highestslotid
= tbl
->server_highest_slotid
;
516 res
->csr_target_highestslotid
= tbl
->target_highest_slotid
;
518 status
= validate_seqid(tbl
, slot
, args
);
521 if (!nfs4_try_to_lock_slot(tbl
, slot
)) {
522 status
= htonl(NFS4ERR_DELAY
);
527 /* The ca_maxresponsesize_cached is 0 with no DRC */
528 if (args
->csa_cachethis
!= 0) {
529 status
= htonl(NFS4ERR_REP_TOO_BIG_TO_CACHE
);
534 * Check for pending referring calls. If a match is found, a
535 * related callback was received before the response to the original
538 if (referring_call_exists(clp
, args
->csa_nrclists
, args
->csa_rclists
)) {
539 status
= htonl(NFS4ERR_DELAY
);
545 * If CB_SEQUENCE returns an error, then the state of the slot
546 * (sequence ID, cached reply) MUST NOT change.
548 slot
->seq_nr
= args
->csa_sequenceid
;
550 spin_unlock(&tbl
->slot_tbl_lock
);
553 cps
->clp
= clp
; /* put in nfs4_callback_compound */
554 for (i
= 0; i
< args
->csa_nrclists
; i
++)
555 kfree(args
->csa_rclists
[i
].rcl_refcalls
);
556 kfree(args
->csa_rclists
);
558 if (status
== htonl(NFS4ERR_RETRY_UNCACHED_REP
)) {
559 cps
->drc_status
= status
;
562 res
->csr_status
= status
;
564 trace_nfs4_cb_sequence(args
, res
, status
);
569 validate_bitmap_values(unsigned long mask
)
571 return (mask
& ~RCA4_TYPE_MASK_ALL
) == 0;
574 __be32
nfs4_callback_recallany(struct cb_recallanyargs
*args
, void *dummy
,
575 struct cb_process_state
*cps
)
580 status
= cpu_to_be32(NFS4ERR_OP_NOT_IN_SESSION
);
581 if (!cps
->clp
) /* set in cb_sequence */
584 dprintk_rcu("NFS: RECALL_ANY callback request from %s\n",
585 rpc_peeraddr2str(cps
->clp
->cl_rpcclient
, RPC_DISPLAY_ADDR
));
587 status
= cpu_to_be32(NFS4ERR_INVAL
);
588 if (!validate_bitmap_values(args
->craa_type_mask
))
591 status
= cpu_to_be32(NFS4_OK
);
592 if (test_bit(RCA4_TYPE_MASK_RDATA_DLG
, (const unsigned long *)
593 &args
->craa_type_mask
))
595 if (test_bit(RCA4_TYPE_MASK_WDATA_DLG
, (const unsigned long *)
596 &args
->craa_type_mask
))
597 flags
|= FMODE_WRITE
;
598 if (test_bit(RCA4_TYPE_MASK_FILE_LAYOUT
, (const unsigned long *)
599 &args
->craa_type_mask
))
600 pnfs_recall_all_layouts(cps
->clp
);
602 nfs_expire_unused_delegation_types(cps
->clp
, flags
);
604 dprintk("%s: exit with status = %d\n", __func__
, ntohl(status
));
608 /* Reduce the fore channel's max_slots to the target value */
609 __be32
nfs4_callback_recallslot(struct cb_recallslotargs
*args
, void *dummy
,
610 struct cb_process_state
*cps
)
612 struct nfs4_slot_table
*fc_tbl
;
615 status
= htonl(NFS4ERR_OP_NOT_IN_SESSION
);
616 if (!cps
->clp
) /* set in cb_sequence */
619 dprintk_rcu("NFS: CB_RECALL_SLOT request from %s target highest slotid %u\n",
620 rpc_peeraddr2str(cps
->clp
->cl_rpcclient
, RPC_DISPLAY_ADDR
),
621 args
->crsa_target_highest_slotid
);
623 fc_tbl
= &cps
->clp
->cl_session
->fc_slot_table
;
625 status
= htonl(NFS4_OK
);
627 nfs41_set_target_slotid(fc_tbl
, args
->crsa_target_highest_slotid
);
628 nfs41_notify_server(cps
->clp
);
630 dprintk("%s: exit with status = %d\n", __func__
, ntohl(status
));
634 __be32
nfs4_callback_notify_lock(struct cb_notify_lock_args
*args
, void *dummy
,
635 struct cb_process_state
*cps
)
637 if (!cps
->clp
) /* set in cb_sequence */
638 return htonl(NFS4ERR_OP_NOT_IN_SESSION
);
640 dprintk_rcu("NFS: CB_NOTIFY_LOCK request from %s\n",
641 rpc_peeraddr2str(cps
->clp
->cl_rpcclient
, RPC_DISPLAY_ADDR
));
643 /* Don't wake anybody if the string looked bogus */
644 if (args
->cbnl_valid
)
645 __wake_up(&cps
->clp
->cl_lock_waitq
, TASK_NORMAL
, 0, args
);
647 return htonl(NFS4_OK
);
649 #endif /* CONFIG_NFS_V4_1 */