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"
20 #define NFSDBG_FACILITY NFSDBG_CALLBACK
23 __be32
nfs4_callback_getattr(struct cb_getattrargs
*args
,
24 struct cb_getattrres
*res
,
25 struct cb_process_state
*cps
)
27 struct nfs_delegation
*delegation
;
28 struct nfs_inode
*nfsi
;
31 res
->status
= htonl(NFS4ERR_OP_NOT_IN_SESSION
);
32 if (!cps
->clp
) /* Always set for v4.0. Set in cb_sequence for v4.1 */
35 res
->bitmap
[0] = res
->bitmap
[1] = 0;
36 res
->status
= htonl(NFS4ERR_BADHANDLE
);
38 dprintk_rcu("NFS: GETATTR callback request from %s\n",
39 rpc_peeraddr2str(cps
->clp
->cl_rpcclient
, RPC_DISPLAY_ADDR
));
41 inode
= nfs_delegation_find_inode(cps
->clp
, &args
->fh
);
46 delegation
= rcu_dereference(nfsi
->delegation
);
47 if (delegation
== NULL
|| (delegation
->type
& FMODE_WRITE
) == 0)
49 res
->size
= i_size_read(inode
);
50 res
->change_attr
= delegation
->change_attr
;
51 if (nfsi
->npages
!= 0)
53 res
->ctime
= inode
->i_ctime
;
54 res
->mtime
= inode
->i_mtime
;
55 res
->bitmap
[0] = (FATTR4_WORD0_CHANGE
|FATTR4_WORD0_SIZE
) &
57 res
->bitmap
[1] = (FATTR4_WORD1_TIME_METADATA
|FATTR4_WORD1_TIME_MODIFY
) &
64 dprintk("%s: exit with status = %d\n", __func__
, ntohl(res
->status
));
68 __be32
nfs4_callback_recall(struct cb_recallargs
*args
, void *dummy
,
69 struct cb_process_state
*cps
)
74 res
= htonl(NFS4ERR_OP_NOT_IN_SESSION
);
75 if (!cps
->clp
) /* Always set for v4.0. Set in cb_sequence for v4.1 */
78 dprintk_rcu("NFS: RECALL callback request from %s\n",
79 rpc_peeraddr2str(cps
->clp
->cl_rpcclient
, RPC_DISPLAY_ADDR
));
81 res
= htonl(NFS4ERR_BADHANDLE
);
82 inode
= nfs_delegation_find_inode(cps
->clp
, &args
->fh
);
85 /* Set up a helper thread to actually return the delegation */
86 switch (nfs_async_inode_return_delegation(inode
, &args
->stateid
)) {
91 res
= htonl(NFS4ERR_BAD_STATEID
);
94 res
= htonl(NFS4ERR_RESOURCE
);
98 dprintk("%s: exit with status = %d\n", __func__
, ntohl(res
));
102 #if defined(CONFIG_NFS_V4_1)
105 * Lookup a layout by filehandle.
107 * Note: gets a refcount on the layout hdr and on its respective inode.
108 * Caller must put the layout hdr and the inode.
110 * TODO: keep track of all layouts (and delegations) in a hash table
111 * hashed by filehandle.
113 static struct pnfs_layout_hdr
* get_layout_by_fh_locked(struct nfs_client
*clp
, struct nfs_fh
*fh
)
115 struct nfs_server
*server
;
117 struct pnfs_layout_hdr
*lo
;
119 list_for_each_entry_rcu(server
, &clp
->cl_superblocks
, client_link
) {
120 list_for_each_entry(lo
, &server
->layouts
, plh_layouts
) {
121 if (nfs_compare_fh(fh
, &NFS_I(lo
->plh_inode
)->fh
))
123 ino
= igrab(lo
->plh_inode
);
126 spin_lock(&ino
->i_lock
);
127 /* Is this layout in the process of being freed? */
128 if (NFS_I(ino
)->layout
!= lo
) {
129 spin_unlock(&ino
->i_lock
);
133 pnfs_get_layout_hdr(lo
);
134 spin_unlock(&ino
->i_lock
);
142 static struct pnfs_layout_hdr
* get_layout_by_fh(struct nfs_client
*clp
, struct nfs_fh
*fh
)
144 struct pnfs_layout_hdr
*lo
;
146 spin_lock(&clp
->cl_lock
);
148 lo
= get_layout_by_fh_locked(clp
, fh
);
150 spin_unlock(&clp
->cl_lock
);
155 static u32
initiate_file_draining(struct nfs_client
*clp
,
156 struct cb_layoutrecallargs
*args
)
159 struct pnfs_layout_hdr
*lo
;
160 u32 rv
= NFS4ERR_NOMATCHING_LAYOUT
;
161 LIST_HEAD(free_me_list
);
163 lo
= get_layout_by_fh(clp
, &args
->cbl_fh
);
165 return NFS4ERR_NOMATCHING_LAYOUT
;
168 spin_lock(&ino
->i_lock
);
169 if (test_bit(NFS_LAYOUT_BULK_RECALL
, &lo
->plh_flags
) ||
170 pnfs_mark_matching_lsegs_invalid(lo
, &free_me_list
,
174 rv
= NFS4ERR_NOMATCHING_LAYOUT
;
175 pnfs_set_layout_stateid(lo
, &args
->cbl_stateid
, true);
176 spin_unlock(&ino
->i_lock
);
177 pnfs_free_lseg_list(&free_me_list
);
178 pnfs_put_layout_hdr(lo
);
183 static u32
initiate_bulk_draining(struct nfs_client
*clp
,
184 struct cb_layoutrecallargs
*args
)
186 struct nfs_server
*server
;
187 struct pnfs_layout_hdr
*lo
;
189 u32 rv
= NFS4ERR_NOMATCHING_LAYOUT
;
190 struct pnfs_layout_hdr
*tmp
;
191 LIST_HEAD(recall_list
);
192 LIST_HEAD(free_me_list
);
193 struct pnfs_layout_range range
= {
194 .iomode
= IOMODE_ANY
,
196 .length
= NFS4_MAX_UINT64
,
199 spin_lock(&clp
->cl_lock
);
201 list_for_each_entry_rcu(server
, &clp
->cl_superblocks
, client_link
) {
202 if ((args
->cbl_recall_type
== RETURN_FSID
) &&
203 memcmp(&server
->fsid
, &args
->cbl_fsid
,
204 sizeof(struct nfs_fsid
)))
207 list_for_each_entry(lo
, &server
->layouts
, plh_layouts
) {
208 ino
= igrab(lo
->plh_inode
);
211 spin_lock(&ino
->i_lock
);
212 /* Is this layout in the process of being freed? */
213 if (NFS_I(ino
)->layout
!= lo
) {
214 spin_unlock(&ino
->i_lock
);
218 pnfs_get_layout_hdr(lo
);
219 spin_unlock(&ino
->i_lock
);
220 list_add(&lo
->plh_bulk_recall
, &recall_list
);
224 spin_unlock(&clp
->cl_lock
);
226 list_for_each_entry_safe(lo
, tmp
,
227 &recall_list
, plh_bulk_recall
) {
229 spin_lock(&ino
->i_lock
);
230 set_bit(NFS_LAYOUT_BULK_RECALL
, &lo
->plh_flags
);
231 if (pnfs_mark_matching_lsegs_invalid(lo
, &free_me_list
, &range
))
233 list_del_init(&lo
->plh_bulk_recall
);
234 spin_unlock(&ino
->i_lock
);
235 pnfs_free_lseg_list(&free_me_list
);
236 pnfs_put_layout_hdr(lo
);
242 static u32
do_callback_layoutrecall(struct nfs_client
*clp
,
243 struct cb_layoutrecallargs
*args
)
247 dprintk("%s enter, type=%i\n", __func__
, args
->cbl_recall_type
);
248 if (args
->cbl_recall_type
== RETURN_FILE
)
249 res
= initiate_file_draining(clp
, args
);
251 res
= initiate_bulk_draining(clp
, args
);
252 dprintk("%s returning %i\n", __func__
, res
);
257 __be32
nfs4_callback_layoutrecall(struct cb_layoutrecallargs
*args
,
258 void *dummy
, struct cb_process_state
*cps
)
262 dprintk("%s: -->\n", __func__
);
265 res
= do_callback_layoutrecall(cps
->clp
, args
);
267 res
= NFS4ERR_OP_NOT_IN_SESSION
;
269 dprintk("%s: exit with status = %d\n", __func__
, res
);
270 return cpu_to_be32(res
);
273 static void pnfs_recall_all_layouts(struct nfs_client
*clp
)
275 struct cb_layoutrecallargs args
;
277 /* Pretend we got a CB_LAYOUTRECALL(ALL) */
278 memset(&args
, 0, sizeof(args
));
279 args
.cbl_recall_type
= RETURN_ALL
;
280 /* FIXME we ignore errors, what should we do? */
281 do_callback_layoutrecall(clp
, &args
);
284 __be32
nfs4_callback_devicenotify(struct cb_devicenotifyargs
*args
,
285 void *dummy
, struct cb_process_state
*cps
)
289 struct nfs_client
*clp
= cps
->clp
;
290 struct nfs_server
*server
= NULL
;
292 dprintk("%s: -->\n", __func__
);
295 res
= cpu_to_be32(NFS4ERR_OP_NOT_IN_SESSION
);
299 for (i
= 0; i
< args
->ndevs
; i
++) {
300 struct cb_devicenotifyitem
*dev
= &args
->devs
[i
];
303 server
->pnfs_curr_ld
->id
!= dev
->cbd_layout_type
) {
305 list_for_each_entry_rcu(server
, &clp
->cl_superblocks
, client_link
)
306 if (server
->pnfs_curr_ld
&&
307 server
->pnfs_curr_ld
->id
== dev
->cbd_layout_type
) {
312 dprintk("%s: layout type %u not found\n",
313 __func__
, dev
->cbd_layout_type
);
318 if (dev
->cbd_notify_type
== NOTIFY_DEVICEID4_CHANGE
)
319 dprintk("%s: NOTIFY_DEVICEID4_CHANGE not supported, "
320 "deleting instead\n", __func__
);
321 nfs4_delete_deviceid(server
->pnfs_curr_ld
, clp
, &dev
->cbd_dev_id
);
326 dprintk("%s: exit with status = %u\n",
327 __func__
, be32_to_cpu(res
));
332 * Validate the sequenceID sent by the server.
333 * Return success if the sequenceID is one more than what we last saw on
334 * this slot, accounting for wraparound. Increments the slot's sequence.
336 * We don't yet implement a duplicate request cache, instead we set the
337 * back channel ca_maxresponsesize_cached to zero. This is OK for now
338 * since we only currently implement idempotent callbacks anyway.
340 * We have a single slot backchannel at this time, so we don't bother
341 * checking the used_slots bit array on the table. The lower layer guarantees
342 * a single outstanding callback request at a time.
345 validate_seqid(struct nfs4_slot_table
*tbl
, struct cb_sequenceargs
* args
)
347 struct nfs4_slot
*slot
;
349 dprintk("%s enter. slotid %d seqid %d\n",
350 __func__
, args
->csa_slotid
, args
->csa_sequenceid
);
352 if (args
->csa_slotid
>= NFS41_BC_MAX_CALLBACKS
)
353 return htonl(NFS4ERR_BADSLOT
);
355 slot
= tbl
->slots
+ args
->csa_slotid
;
356 dprintk("%s slot table seqid: %d\n", __func__
, slot
->seq_nr
);
359 if (likely(args
->csa_sequenceid
== slot
->seq_nr
+ 1)) {
365 if (args
->csa_sequenceid
== slot
->seq_nr
) {
366 dprintk("%s seqid %d is a replay\n",
367 __func__
, args
->csa_sequenceid
);
368 /* Signal process_op to set this error on next op */
369 if (args
->csa_cachethis
== 0)
370 return htonl(NFS4ERR_RETRY_UNCACHED_REP
);
372 /* The ca_maxresponsesize_cached is 0 with no DRC */
373 else if (args
->csa_cachethis
== 1)
374 return htonl(NFS4ERR_REP_TOO_BIG_TO_CACHE
);
378 if (args
->csa_sequenceid
== 1 && (slot
->seq_nr
+ 1) == 0) {
383 /* Misordered request */
384 return htonl(NFS4ERR_SEQ_MISORDERED
);
386 tbl
->highest_used_slotid
= args
->csa_slotid
;
387 return htonl(NFS4_OK
);
391 * For each referring call triple, check the session's slot table for
392 * a match. If the slot is in use and the sequence numbers match, the
393 * client is still waiting for a response to the original request.
395 static bool referring_call_exists(struct nfs_client
*clp
,
397 struct referring_call_list
*rclists
)
401 struct nfs4_session
*session
;
402 struct nfs4_slot_table
*tbl
;
403 struct referring_call_list
*rclist
;
404 struct referring_call
*ref
;
407 * XXX When client trunking is implemented, this becomes
408 * a session lookup from within the loop
410 session
= clp
->cl_session
;
411 tbl
= &session
->fc_slot_table
;
413 for (i
= 0; i
< nrclists
; i
++) {
414 rclist
= &rclists
[i
];
415 if (memcmp(session
->sess_id
.data
,
416 rclist
->rcl_sessionid
.data
,
417 NFS4_MAX_SESSIONID_LEN
) != 0)
420 for (j
= 0; j
< rclist
->rcl_nrefcalls
; j
++) {
421 ref
= &rclist
->rcl_refcalls
[j
];
423 dprintk("%s: sessionid %x:%x:%x:%x sequenceid %u "
424 "slotid %u\n", __func__
,
425 ((u32
*)&rclist
->rcl_sessionid
.data
)[0],
426 ((u32
*)&rclist
->rcl_sessionid
.data
)[1],
427 ((u32
*)&rclist
->rcl_sessionid
.data
)[2],
428 ((u32
*)&rclist
->rcl_sessionid
.data
)[3],
429 ref
->rc_sequenceid
, ref
->rc_slotid
);
431 spin_lock(&tbl
->slot_tbl_lock
);
432 status
= (test_bit(ref
->rc_slotid
, tbl
->used_slots
) &&
433 tbl
->slots
[ref
->rc_slotid
].seq_nr
==
435 spin_unlock(&tbl
->slot_tbl_lock
);
445 __be32
nfs4_callback_sequence(struct cb_sequenceargs
*args
,
446 struct cb_sequenceres
*res
,
447 struct cb_process_state
*cps
)
449 struct nfs4_slot_table
*tbl
;
450 struct nfs_client
*clp
;
452 __be32 status
= htonl(NFS4ERR_BADSESSION
);
454 clp
= nfs4_find_client_sessionid(cps
->net
, args
->csa_addr
, &args
->csa_sessionid
);
458 tbl
= &clp
->cl_session
->bc_slot_table
;
460 spin_lock(&tbl
->slot_tbl_lock
);
461 /* state manager is resetting the session */
462 if (test_bit(NFS4_SESSION_DRAINING
, &clp
->cl_session
->session_state
)) {
463 spin_unlock(&tbl
->slot_tbl_lock
);
464 status
= htonl(NFS4ERR_DELAY
);
465 /* Return NFS4ERR_BADSESSION if we're draining the session
466 * in order to reset it.
468 if (test_bit(NFS4CLNT_SESSION_RESET
, &clp
->cl_state
))
469 status
= htonl(NFS4ERR_BADSESSION
);
473 status
= validate_seqid(&clp
->cl_session
->bc_slot_table
, args
);
474 spin_unlock(&tbl
->slot_tbl_lock
);
478 cps
->slotid
= args
->csa_slotid
;
481 * Check for pending referring calls. If a match is found, a
482 * related callback was received before the response to the original
485 if (referring_call_exists(clp
, args
->csa_nrclists
, args
->csa_rclists
)) {
486 status
= htonl(NFS4ERR_DELAY
);
490 memcpy(&res
->csr_sessionid
, &args
->csa_sessionid
,
491 sizeof(res
->csr_sessionid
));
492 res
->csr_sequenceid
= args
->csa_sequenceid
;
493 res
->csr_slotid
= args
->csa_slotid
;
494 res
->csr_highestslotid
= NFS41_BC_MAX_CALLBACKS
- 1;
495 res
->csr_target_highestslotid
= NFS41_BC_MAX_CALLBACKS
- 1;
498 cps
->clp
= clp
; /* put in nfs4_callback_compound */
499 for (i
= 0; i
< args
->csa_nrclists
; i
++)
500 kfree(args
->csa_rclists
[i
].rcl_refcalls
);
501 kfree(args
->csa_rclists
);
503 if (status
== htonl(NFS4ERR_RETRY_UNCACHED_REP
)) {
504 cps
->drc_status
= status
;
507 res
->csr_status
= status
;
509 dprintk("%s: exit with status = %d res->csr_status %d\n", __func__
,
510 ntohl(status
), ntohl(res
->csr_status
));
515 validate_bitmap_values(unsigned long mask
)
517 return (mask
& ~RCA4_TYPE_MASK_ALL
) == 0;
520 __be32
nfs4_callback_recallany(struct cb_recallanyargs
*args
, void *dummy
,
521 struct cb_process_state
*cps
)
526 status
= cpu_to_be32(NFS4ERR_OP_NOT_IN_SESSION
);
527 if (!cps
->clp
) /* set in cb_sequence */
530 dprintk_rcu("NFS: RECALL_ANY callback request from %s\n",
531 rpc_peeraddr2str(cps
->clp
->cl_rpcclient
, RPC_DISPLAY_ADDR
));
533 status
= cpu_to_be32(NFS4ERR_INVAL
);
534 if (!validate_bitmap_values(args
->craa_type_mask
))
537 status
= cpu_to_be32(NFS4_OK
);
538 if (test_bit(RCA4_TYPE_MASK_RDATA_DLG
, (const unsigned long *)
539 &args
->craa_type_mask
))
541 if (test_bit(RCA4_TYPE_MASK_WDATA_DLG
, (const unsigned long *)
542 &args
->craa_type_mask
))
543 flags
|= FMODE_WRITE
;
544 if (test_bit(RCA4_TYPE_MASK_FILE_LAYOUT
, (const unsigned long *)
545 &args
->craa_type_mask
))
546 pnfs_recall_all_layouts(cps
->clp
);
548 nfs_expire_all_delegation_types(cps
->clp
, flags
);
550 dprintk("%s: exit with status = %d\n", __func__
, ntohl(status
));
554 /* Reduce the fore channel's max_slots to the target value */
555 __be32
nfs4_callback_recallslot(struct cb_recallslotargs
*args
, void *dummy
,
556 struct cb_process_state
*cps
)
558 struct nfs4_slot_table
*fc_tbl
;
561 status
= htonl(NFS4ERR_OP_NOT_IN_SESSION
);
562 if (!cps
->clp
) /* set in cb_sequence */
565 dprintk_rcu("NFS: CB_RECALL_SLOT request from %s target highest slotid %d\n",
566 rpc_peeraddr2str(cps
->clp
->cl_rpcclient
, RPC_DISPLAY_ADDR
),
567 args
->crsa_target_highest_slotid
);
569 fc_tbl
= &cps
->clp
->cl_session
->fc_slot_table
;
571 status
= htonl(NFS4_OK
);
573 nfs41_set_target_slotid(fc_tbl
, args
->crsa_target_highest_slotid
);
574 nfs41_server_notify_target_slotid_update(cps
->clp
);
576 dprintk("%s: exit with status = %d\n", __func__
, ntohl(status
));
579 #endif /* CONFIG_NFS_V4_1 */