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"
21 #define NFSDBG_FACILITY NFSDBG_CALLBACK
24 __be32
nfs4_callback_getattr(struct cb_getattrargs
*args
,
25 struct cb_getattrres
*res
,
26 struct cb_process_state
*cps
)
28 struct nfs_delegation
*delegation
;
29 struct nfs_inode
*nfsi
;
32 res
->status
= htonl(NFS4ERR_OP_NOT_IN_SESSION
);
33 if (!cps
->clp
) /* Always set for v4.0. Set in cb_sequence for v4.1 */
36 res
->bitmap
[0] = res
->bitmap
[1] = 0;
37 res
->status
= htonl(NFS4ERR_BADHANDLE
);
39 dprintk_rcu("NFS: GETATTR callback request from %s\n",
40 rpc_peeraddr2str(cps
->clp
->cl_rpcclient
, RPC_DISPLAY_ADDR
));
42 inode
= nfs_delegation_find_inode(cps
->clp
, &args
->fh
);
47 delegation
= rcu_dereference(nfsi
->delegation
);
48 if (delegation
== NULL
|| (delegation
->type
& FMODE_WRITE
) == 0)
50 res
->size
= i_size_read(inode
);
51 res
->change_attr
= delegation
->change_attr
;
52 if (nfsi
->npages
!= 0)
54 res
->ctime
= inode
->i_ctime
;
55 res
->mtime
= inode
->i_mtime
;
56 res
->bitmap
[0] = (FATTR4_WORD0_CHANGE
|FATTR4_WORD0_SIZE
) &
58 res
->bitmap
[1] = (FATTR4_WORD1_TIME_METADATA
|FATTR4_WORD1_TIME_MODIFY
) &
65 dprintk("%s: exit with status = %d\n", __func__
, ntohl(res
->status
));
69 __be32
nfs4_callback_recall(struct cb_recallargs
*args
, void *dummy
,
70 struct cb_process_state
*cps
)
75 res
= htonl(NFS4ERR_OP_NOT_IN_SESSION
);
76 if (!cps
->clp
) /* Always set for v4.0. Set in cb_sequence for v4.1 */
79 dprintk_rcu("NFS: RECALL callback request from %s\n",
80 rpc_peeraddr2str(cps
->clp
->cl_rpcclient
, RPC_DISPLAY_ADDR
));
82 res
= htonl(NFS4ERR_BADHANDLE
);
83 inode
= nfs_delegation_find_inode(cps
->clp
, &args
->fh
);
86 /* Set up a helper thread to actually return the delegation */
87 switch (nfs_async_inode_return_delegation(inode
, &args
->stateid
)) {
92 res
= htonl(NFS4ERR_BAD_STATEID
);
95 res
= htonl(NFS4ERR_RESOURCE
);
97 trace_nfs4_recall_delegation(inode
, -ntohl(res
));
100 dprintk("%s: exit with status = %d\n", __func__
, ntohl(res
));
104 #if defined(CONFIG_NFS_V4_1)
107 * Lookup a layout by filehandle.
109 * Note: gets a refcount on the layout hdr and on its respective inode.
110 * Caller must put the layout hdr and the inode.
112 * TODO: keep track of all layouts (and delegations) in a hash table
113 * hashed by filehandle.
115 static struct pnfs_layout_hdr
* get_layout_by_fh_locked(struct nfs_client
*clp
, struct nfs_fh
*fh
)
117 struct nfs_server
*server
;
119 struct pnfs_layout_hdr
*lo
;
121 list_for_each_entry_rcu(server
, &clp
->cl_superblocks
, client_link
) {
122 list_for_each_entry(lo
, &server
->layouts
, plh_layouts
) {
123 if (nfs_compare_fh(fh
, &NFS_I(lo
->plh_inode
)->fh
))
125 ino
= igrab(lo
->plh_inode
);
128 spin_lock(&ino
->i_lock
);
129 /* Is this layout in the process of being freed? */
130 if (NFS_I(ino
)->layout
!= lo
) {
131 spin_unlock(&ino
->i_lock
);
135 pnfs_get_layout_hdr(lo
);
136 spin_unlock(&ino
->i_lock
);
144 static struct pnfs_layout_hdr
* get_layout_by_fh(struct nfs_client
*clp
, struct nfs_fh
*fh
)
146 struct pnfs_layout_hdr
*lo
;
148 spin_lock(&clp
->cl_lock
);
150 lo
= get_layout_by_fh_locked(clp
, fh
);
152 spin_unlock(&clp
->cl_lock
);
157 static u32
initiate_file_draining(struct nfs_client
*clp
,
158 struct cb_layoutrecallargs
*args
)
161 struct pnfs_layout_hdr
*lo
;
162 u32 rv
= NFS4ERR_NOMATCHING_LAYOUT
;
163 LIST_HEAD(free_me_list
);
165 lo
= get_layout_by_fh(clp
, &args
->cbl_fh
);
167 return NFS4ERR_NOMATCHING_LAYOUT
;
170 spin_lock(&ino
->i_lock
);
171 if (test_bit(NFS_LAYOUT_BULK_RECALL
, &lo
->plh_flags
) ||
172 pnfs_mark_matching_lsegs_invalid(lo
, &free_me_list
,
176 rv
= NFS4ERR_NOMATCHING_LAYOUT
;
177 pnfs_set_layout_stateid(lo
, &args
->cbl_stateid
, true);
178 spin_unlock(&ino
->i_lock
);
179 pnfs_free_lseg_list(&free_me_list
);
180 pnfs_put_layout_hdr(lo
);
185 static u32
initiate_bulk_draining(struct nfs_client
*clp
,
186 struct cb_layoutrecallargs
*args
)
190 if (args
->cbl_recall_type
== RETURN_FSID
)
191 stat
= pnfs_destroy_layouts_byfsid(clp
, &args
->cbl_fsid
, true);
193 stat
= pnfs_destroy_layouts_byclid(clp
, true);
195 return NFS4ERR_DELAY
;
196 return NFS4ERR_NOMATCHING_LAYOUT
;
199 static u32
do_callback_layoutrecall(struct nfs_client
*clp
,
200 struct cb_layoutrecallargs
*args
)
204 dprintk("%s enter, type=%i\n", __func__
, args
->cbl_recall_type
);
205 if (args
->cbl_recall_type
== RETURN_FILE
)
206 res
= initiate_file_draining(clp
, args
);
208 res
= initiate_bulk_draining(clp
, args
);
209 dprintk("%s returning %i\n", __func__
, res
);
214 __be32
nfs4_callback_layoutrecall(struct cb_layoutrecallargs
*args
,
215 void *dummy
, struct cb_process_state
*cps
)
219 dprintk("%s: -->\n", __func__
);
222 res
= do_callback_layoutrecall(cps
->clp
, args
);
224 res
= NFS4ERR_OP_NOT_IN_SESSION
;
226 dprintk("%s: exit with status = %d\n", __func__
, res
);
227 return cpu_to_be32(res
);
230 static void pnfs_recall_all_layouts(struct nfs_client
*clp
)
232 struct cb_layoutrecallargs args
;
234 /* Pretend we got a CB_LAYOUTRECALL(ALL) */
235 memset(&args
, 0, sizeof(args
));
236 args
.cbl_recall_type
= RETURN_ALL
;
237 /* FIXME we ignore errors, what should we do? */
238 do_callback_layoutrecall(clp
, &args
);
241 __be32
nfs4_callback_devicenotify(struct cb_devicenotifyargs
*args
,
242 void *dummy
, struct cb_process_state
*cps
)
246 struct nfs_client
*clp
= cps
->clp
;
247 struct nfs_server
*server
= NULL
;
249 dprintk("%s: -->\n", __func__
);
252 res
= cpu_to_be32(NFS4ERR_OP_NOT_IN_SESSION
);
256 for (i
= 0; i
< args
->ndevs
; i
++) {
257 struct cb_devicenotifyitem
*dev
= &args
->devs
[i
];
260 server
->pnfs_curr_ld
->id
!= dev
->cbd_layout_type
) {
262 list_for_each_entry_rcu(server
, &clp
->cl_superblocks
, client_link
)
263 if (server
->pnfs_curr_ld
&&
264 server
->pnfs_curr_ld
->id
== dev
->cbd_layout_type
) {
269 dprintk("%s: layout type %u not found\n",
270 __func__
, dev
->cbd_layout_type
);
275 if (dev
->cbd_notify_type
== NOTIFY_DEVICEID4_CHANGE
)
276 dprintk("%s: NOTIFY_DEVICEID4_CHANGE not supported, "
277 "deleting instead\n", __func__
);
278 nfs4_delete_deviceid(server
->pnfs_curr_ld
, clp
, &dev
->cbd_dev_id
);
283 dprintk("%s: exit with status = %u\n",
284 __func__
, be32_to_cpu(res
));
289 * Validate the sequenceID sent by the server.
290 * Return success if the sequenceID is one more than what we last saw on
291 * this slot, accounting for wraparound. Increments the slot's sequence.
293 * We don't yet implement a duplicate request cache, instead we set the
294 * back channel ca_maxresponsesize_cached to zero. This is OK for now
295 * since we only currently implement idempotent callbacks anyway.
297 * We have a single slot backchannel at this time, so we don't bother
298 * checking the used_slots bit array on the table. The lower layer guarantees
299 * a single outstanding callback request at a time.
302 validate_seqid(struct nfs4_slot_table
*tbl
, struct cb_sequenceargs
* args
)
304 struct nfs4_slot
*slot
;
306 dprintk("%s enter. slotid %d seqid %d\n",
307 __func__
, args
->csa_slotid
, args
->csa_sequenceid
);
309 if (args
->csa_slotid
>= NFS41_BC_MAX_CALLBACKS
)
310 return htonl(NFS4ERR_BADSLOT
);
312 slot
= tbl
->slots
+ args
->csa_slotid
;
313 dprintk("%s slot table seqid: %d\n", __func__
, slot
->seq_nr
);
316 if (likely(args
->csa_sequenceid
== slot
->seq_nr
+ 1)) {
322 if (args
->csa_sequenceid
== slot
->seq_nr
) {
323 dprintk("%s seqid %d is a replay\n",
324 __func__
, args
->csa_sequenceid
);
325 /* Signal process_op to set this error on next op */
326 if (args
->csa_cachethis
== 0)
327 return htonl(NFS4ERR_RETRY_UNCACHED_REP
);
329 /* The ca_maxresponsesize_cached is 0 with no DRC */
330 else if (args
->csa_cachethis
== 1)
331 return htonl(NFS4ERR_REP_TOO_BIG_TO_CACHE
);
335 if (args
->csa_sequenceid
== 1 && (slot
->seq_nr
+ 1) == 0) {
340 /* Misordered request */
341 return htonl(NFS4ERR_SEQ_MISORDERED
);
343 tbl
->highest_used_slotid
= args
->csa_slotid
;
344 return htonl(NFS4_OK
);
348 * For each referring call triple, check the session's slot table for
349 * a match. If the slot is in use and the sequence numbers match, the
350 * client is still waiting for a response to the original request.
352 static bool referring_call_exists(struct nfs_client
*clp
,
354 struct referring_call_list
*rclists
)
358 struct nfs4_session
*session
;
359 struct nfs4_slot_table
*tbl
;
360 struct referring_call_list
*rclist
;
361 struct referring_call
*ref
;
364 * XXX When client trunking is implemented, this becomes
365 * a session lookup from within the loop
367 session
= clp
->cl_session
;
368 tbl
= &session
->fc_slot_table
;
370 for (i
= 0; i
< nrclists
; i
++) {
371 rclist
= &rclists
[i
];
372 if (memcmp(session
->sess_id
.data
,
373 rclist
->rcl_sessionid
.data
,
374 NFS4_MAX_SESSIONID_LEN
) != 0)
377 for (j
= 0; j
< rclist
->rcl_nrefcalls
; j
++) {
378 ref
= &rclist
->rcl_refcalls
[j
];
380 dprintk("%s: sessionid %x:%x:%x:%x sequenceid %u "
381 "slotid %u\n", __func__
,
382 ((u32
*)&rclist
->rcl_sessionid
.data
)[0],
383 ((u32
*)&rclist
->rcl_sessionid
.data
)[1],
384 ((u32
*)&rclist
->rcl_sessionid
.data
)[2],
385 ((u32
*)&rclist
->rcl_sessionid
.data
)[3],
386 ref
->rc_sequenceid
, ref
->rc_slotid
);
388 spin_lock(&tbl
->slot_tbl_lock
);
389 status
= (test_bit(ref
->rc_slotid
, tbl
->used_slots
) &&
390 tbl
->slots
[ref
->rc_slotid
].seq_nr
==
392 spin_unlock(&tbl
->slot_tbl_lock
);
402 __be32
nfs4_callback_sequence(struct cb_sequenceargs
*args
,
403 struct cb_sequenceres
*res
,
404 struct cb_process_state
*cps
)
406 struct nfs4_slot_table
*tbl
;
407 struct nfs_client
*clp
;
409 __be32 status
= htonl(NFS4ERR_BADSESSION
);
411 clp
= nfs4_find_client_sessionid(cps
->net
, args
->csa_addr
,
412 &args
->csa_sessionid
, cps
->minorversion
);
416 tbl
= &clp
->cl_session
->bc_slot_table
;
418 spin_lock(&tbl
->slot_tbl_lock
);
419 /* state manager is resetting the session */
420 if (test_bit(NFS4_SLOT_TBL_DRAINING
, &tbl
->slot_tbl_state
)) {
421 spin_unlock(&tbl
->slot_tbl_lock
);
422 status
= htonl(NFS4ERR_DELAY
);
423 /* Return NFS4ERR_BADSESSION if we're draining the session
424 * in order to reset it.
426 if (test_bit(NFS4CLNT_SESSION_RESET
, &clp
->cl_state
))
427 status
= htonl(NFS4ERR_BADSESSION
);
431 status
= validate_seqid(&clp
->cl_session
->bc_slot_table
, args
);
432 spin_unlock(&tbl
->slot_tbl_lock
);
436 cps
->slotid
= args
->csa_slotid
;
439 * Check for pending referring calls. If a match is found, a
440 * related callback was received before the response to the original
443 if (referring_call_exists(clp
, args
->csa_nrclists
, args
->csa_rclists
)) {
444 status
= htonl(NFS4ERR_DELAY
);
448 memcpy(&res
->csr_sessionid
, &args
->csa_sessionid
,
449 sizeof(res
->csr_sessionid
));
450 res
->csr_sequenceid
= args
->csa_sequenceid
;
451 res
->csr_slotid
= args
->csa_slotid
;
452 res
->csr_highestslotid
= NFS41_BC_MAX_CALLBACKS
- 1;
453 res
->csr_target_highestslotid
= NFS41_BC_MAX_CALLBACKS
- 1;
456 cps
->clp
= clp
; /* put in nfs4_callback_compound */
457 for (i
= 0; i
< args
->csa_nrclists
; i
++)
458 kfree(args
->csa_rclists
[i
].rcl_refcalls
);
459 kfree(args
->csa_rclists
);
461 if (status
== htonl(NFS4ERR_RETRY_UNCACHED_REP
)) {
462 cps
->drc_status
= status
;
465 res
->csr_status
= status
;
467 dprintk("%s: exit with status = %d res->csr_status %d\n", __func__
,
468 ntohl(status
), ntohl(res
->csr_status
));
473 validate_bitmap_values(unsigned long mask
)
475 return (mask
& ~RCA4_TYPE_MASK_ALL
) == 0;
478 __be32
nfs4_callback_recallany(struct cb_recallanyargs
*args
, void *dummy
,
479 struct cb_process_state
*cps
)
484 status
= cpu_to_be32(NFS4ERR_OP_NOT_IN_SESSION
);
485 if (!cps
->clp
) /* set in cb_sequence */
488 dprintk_rcu("NFS: RECALL_ANY callback request from %s\n",
489 rpc_peeraddr2str(cps
->clp
->cl_rpcclient
, RPC_DISPLAY_ADDR
));
491 status
= cpu_to_be32(NFS4ERR_INVAL
);
492 if (!validate_bitmap_values(args
->craa_type_mask
))
495 status
= cpu_to_be32(NFS4_OK
);
496 if (test_bit(RCA4_TYPE_MASK_RDATA_DLG
, (const unsigned long *)
497 &args
->craa_type_mask
))
499 if (test_bit(RCA4_TYPE_MASK_WDATA_DLG
, (const unsigned long *)
500 &args
->craa_type_mask
))
501 flags
|= FMODE_WRITE
;
502 if (test_bit(RCA4_TYPE_MASK_FILE_LAYOUT
, (const unsigned long *)
503 &args
->craa_type_mask
))
504 pnfs_recall_all_layouts(cps
->clp
);
506 nfs_expire_unused_delegation_types(cps
->clp
, flags
);
508 dprintk("%s: exit with status = %d\n", __func__
, ntohl(status
));
512 /* Reduce the fore channel's max_slots to the target value */
513 __be32
nfs4_callback_recallslot(struct cb_recallslotargs
*args
, void *dummy
,
514 struct cb_process_state
*cps
)
516 struct nfs4_slot_table
*fc_tbl
;
519 status
= htonl(NFS4ERR_OP_NOT_IN_SESSION
);
520 if (!cps
->clp
) /* set in cb_sequence */
523 dprintk_rcu("NFS: CB_RECALL_SLOT request from %s target highest slotid %d\n",
524 rpc_peeraddr2str(cps
->clp
->cl_rpcclient
, RPC_DISPLAY_ADDR
),
525 args
->crsa_target_highest_slotid
);
527 fc_tbl
= &cps
->clp
->cl_session
->fc_slot_table
;
529 status
= htonl(NFS4_OK
);
531 nfs41_set_target_slotid(fc_tbl
, args
->crsa_target_highest_slotid
);
532 nfs41_server_notify_target_slotid_update(cps
->clp
);
534 dprintk("%s: exit with status = %d\n", __func__
, ntohl(status
));
537 #endif /* CONFIG_NFS_V4_1 */