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>
13 #include "delegation.h"
18 #define NFSDBG_FACILITY NFSDBG_CALLBACK
21 __be32
nfs4_callback_getattr(struct cb_getattrargs
*args
,
22 struct cb_getattrres
*res
,
23 struct cb_process_state
*cps
)
25 struct nfs_delegation
*delegation
;
26 struct nfs_inode
*nfsi
;
29 res
->status
= htonl(NFS4ERR_OP_NOT_IN_SESSION
);
30 if (!cps
->clp
) /* Always set for v4.0. Set in cb_sequence for v4.1 */
33 res
->bitmap
[0] = res
->bitmap
[1] = 0;
34 res
->status
= htonl(NFS4ERR_BADHANDLE
);
36 dprintk("NFS: GETATTR callback request from %s\n",
37 rpc_peeraddr2str(cps
->clp
->cl_rpcclient
, RPC_DISPLAY_ADDR
));
39 inode
= nfs_delegation_find_inode(cps
->clp
, &args
->fh
);
44 delegation
= rcu_dereference(nfsi
->delegation
);
45 if (delegation
== NULL
|| (delegation
->type
& FMODE_WRITE
) == 0)
47 res
->size
= i_size_read(inode
);
48 res
->change_attr
= delegation
->change_attr
;
49 if (nfsi
->npages
!= 0)
51 res
->ctime
= inode
->i_ctime
;
52 res
->mtime
= inode
->i_mtime
;
53 res
->bitmap
[0] = (FATTR4_WORD0_CHANGE
|FATTR4_WORD0_SIZE
) &
55 res
->bitmap
[1] = (FATTR4_WORD1_TIME_METADATA
|FATTR4_WORD1_TIME_MODIFY
) &
62 dprintk("%s: exit with status = %d\n", __func__
, ntohl(res
->status
));
66 __be32
nfs4_callback_recall(struct cb_recallargs
*args
, void *dummy
,
67 struct cb_process_state
*cps
)
72 res
= htonl(NFS4ERR_OP_NOT_IN_SESSION
);
73 if (!cps
->clp
) /* Always set for v4.0. Set in cb_sequence for v4.1 */
76 dprintk("NFS: RECALL callback request from %s\n",
77 rpc_peeraddr2str(cps
->clp
->cl_rpcclient
, RPC_DISPLAY_ADDR
));
79 res
= htonl(NFS4ERR_BADHANDLE
);
80 inode
= nfs_delegation_find_inode(cps
->clp
, &args
->fh
);
83 /* Set up a helper thread to actually return the delegation */
84 switch (nfs_async_inode_return_delegation(inode
, &args
->stateid
)) {
90 res
= htonl(NFS4ERR_BAD_STATEID
);
93 res
= htonl(NFS4ERR_RESOURCE
);
97 dprintk("%s: exit with status = %d\n", __func__
, ntohl(res
));
101 int nfs4_validate_delegation_stateid(struct nfs_delegation
*delegation
, const nfs4_stateid
*stateid
)
103 if (delegation
== NULL
|| memcmp(delegation
->stateid
.data
, stateid
->data
,
104 sizeof(delegation
->stateid
.data
)) != 0)
109 #if defined(CONFIG_NFS_V4_1)
112 * Lookup a layout by filehandle.
114 * Note: gets a refcount on the layout hdr and on its respective inode.
115 * Caller must put the layout hdr and the inode.
117 * TODO: keep track of all layouts (and delegations) in a hash table
118 * hashed by filehandle.
120 static struct pnfs_layout_hdr
* get_layout_by_fh_locked(struct nfs_client
*clp
, struct nfs_fh
*fh
)
122 struct nfs_server
*server
;
124 struct pnfs_layout_hdr
*lo
;
126 list_for_each_entry_rcu(server
, &clp
->cl_superblocks
, client_link
) {
127 list_for_each_entry(lo
, &server
->layouts
, plh_layouts
) {
128 if (nfs_compare_fh(fh
, &NFS_I(lo
->plh_inode
)->fh
))
130 ino
= igrab(lo
->plh_inode
);
141 static struct pnfs_layout_hdr
* get_layout_by_fh(struct nfs_client
*clp
, struct nfs_fh
*fh
)
143 struct pnfs_layout_hdr
*lo
;
145 spin_lock(&clp
->cl_lock
);
147 lo
= get_layout_by_fh_locked(clp
, fh
);
149 spin_unlock(&clp
->cl_lock
);
154 static u32
initiate_file_draining(struct nfs_client
*clp
,
155 struct cb_layoutrecallargs
*args
)
158 struct pnfs_layout_hdr
*lo
;
159 u32 rv
= NFS4ERR_NOMATCHING_LAYOUT
;
160 LIST_HEAD(free_me_list
);
162 lo
= get_layout_by_fh(clp
, &args
->cbl_fh
);
164 return NFS4ERR_NOMATCHING_LAYOUT
;
167 spin_lock(&ino
->i_lock
);
168 if (test_bit(NFS_LAYOUT_BULK_RECALL
, &lo
->plh_flags
) ||
169 mark_matching_lsegs_invalid(lo
, &free_me_list
,
173 rv
= NFS4ERR_NOMATCHING_LAYOUT
;
174 pnfs_set_layout_stateid(lo
, &args
->cbl_stateid
, true);
175 spin_unlock(&ino
->i_lock
);
176 pnfs_free_lseg_list(&free_me_list
);
182 static u32
initiate_bulk_draining(struct nfs_client
*clp
,
183 struct cb_layoutrecallargs
*args
)
185 struct nfs_server
*server
;
186 struct pnfs_layout_hdr
*lo
;
188 u32 rv
= NFS4ERR_NOMATCHING_LAYOUT
;
189 struct pnfs_layout_hdr
*tmp
;
190 LIST_HEAD(recall_list
);
191 LIST_HEAD(free_me_list
);
192 struct pnfs_layout_range range
= {
193 .iomode
= IOMODE_ANY
,
195 .length
= NFS4_MAX_UINT64
,
198 spin_lock(&clp
->cl_lock
);
200 list_for_each_entry_rcu(server
, &clp
->cl_superblocks
, client_link
) {
201 if ((args
->cbl_recall_type
== RETURN_FSID
) &&
202 memcmp(&server
->fsid
, &args
->cbl_fsid
,
203 sizeof(struct nfs_fsid
)))
206 list_for_each_entry(lo
, &server
->layouts
, plh_layouts
) {
207 if (!igrab(lo
->plh_inode
))
210 BUG_ON(!list_empty(&lo
->plh_bulk_recall
));
211 list_add(&lo
->plh_bulk_recall
, &recall_list
);
215 spin_unlock(&clp
->cl_lock
);
217 list_for_each_entry_safe(lo
, tmp
,
218 &recall_list
, plh_bulk_recall
) {
220 spin_lock(&ino
->i_lock
);
221 set_bit(NFS_LAYOUT_BULK_RECALL
, &lo
->plh_flags
);
222 if (mark_matching_lsegs_invalid(lo
, &free_me_list
, &range
))
224 list_del_init(&lo
->plh_bulk_recall
);
225 spin_unlock(&ino
->i_lock
);
226 pnfs_free_lseg_list(&free_me_list
);
233 static u32
do_callback_layoutrecall(struct nfs_client
*clp
,
234 struct cb_layoutrecallargs
*args
)
238 dprintk("%s enter, type=%i\n", __func__
, args
->cbl_recall_type
);
239 if (args
->cbl_recall_type
== RETURN_FILE
)
240 res
= initiate_file_draining(clp
, args
);
242 res
= initiate_bulk_draining(clp
, args
);
243 dprintk("%s returning %i\n", __func__
, res
);
248 __be32
nfs4_callback_layoutrecall(struct cb_layoutrecallargs
*args
,
249 void *dummy
, struct cb_process_state
*cps
)
253 dprintk("%s: -->\n", __func__
);
256 res
= do_callback_layoutrecall(cps
->clp
, args
);
258 res
= NFS4ERR_OP_NOT_IN_SESSION
;
260 dprintk("%s: exit with status = %d\n", __func__
, res
);
261 return cpu_to_be32(res
);
264 static void pnfs_recall_all_layouts(struct nfs_client
*clp
)
266 struct cb_layoutrecallargs args
;
268 /* Pretend we got a CB_LAYOUTRECALL(ALL) */
269 memset(&args
, 0, sizeof(args
));
270 args
.cbl_recall_type
= RETURN_ALL
;
271 /* FIXME we ignore errors, what should we do? */
272 do_callback_layoutrecall(clp
, &args
);
275 __be32
nfs4_callback_devicenotify(struct cb_devicenotifyargs
*args
,
276 void *dummy
, struct cb_process_state
*cps
)
280 struct nfs_client
*clp
= cps
->clp
;
281 struct nfs_server
*server
= NULL
;
283 dprintk("%s: -->\n", __func__
);
286 res
= cpu_to_be32(NFS4ERR_OP_NOT_IN_SESSION
);
290 for (i
= 0; i
< args
->ndevs
; i
++) {
291 struct cb_devicenotifyitem
*dev
= &args
->devs
[i
];
294 server
->pnfs_curr_ld
->id
!= dev
->cbd_layout_type
) {
296 list_for_each_entry_rcu(server
, &clp
->cl_superblocks
, client_link
)
297 if (server
->pnfs_curr_ld
&&
298 server
->pnfs_curr_ld
->id
== dev
->cbd_layout_type
) {
303 dprintk("%s: layout type %u not found\n",
304 __func__
, dev
->cbd_layout_type
);
309 if (dev
->cbd_notify_type
== NOTIFY_DEVICEID4_CHANGE
)
310 dprintk("%s: NOTIFY_DEVICEID4_CHANGE not supported, "
311 "deleting instead\n", __func__
);
312 nfs4_delete_deviceid(server
->pnfs_curr_ld
, clp
, &dev
->cbd_dev_id
);
317 dprintk("%s: exit with status = %u\n",
318 __func__
, be32_to_cpu(res
));
322 int nfs41_validate_delegation_stateid(struct nfs_delegation
*delegation
, const nfs4_stateid
*stateid
)
324 if (delegation
== NULL
)
327 if (stateid
->stateid
.seqid
!= 0)
329 if (memcmp(&delegation
->stateid
.stateid
.other
,
330 &stateid
->stateid
.other
,
331 NFS4_STATEID_OTHER_SIZE
))
338 * Validate the sequenceID sent by the server.
339 * Return success if the sequenceID is one more than what we last saw on
340 * this slot, accounting for wraparound. Increments the slot's sequence.
342 * We don't yet implement a duplicate request cache, instead we set the
343 * back channel ca_maxresponsesize_cached to zero. This is OK for now
344 * since we only currently implement idempotent callbacks anyway.
346 * We have a single slot backchannel at this time, so we don't bother
347 * checking the used_slots bit array on the table. The lower layer guarantees
348 * a single outstanding callback request at a time.
351 validate_seqid(struct nfs4_slot_table
*tbl
, struct cb_sequenceargs
* args
)
353 struct nfs4_slot
*slot
;
355 dprintk("%s enter. slotid %d seqid %d\n",
356 __func__
, args
->csa_slotid
, args
->csa_sequenceid
);
358 if (args
->csa_slotid
>= NFS41_BC_MAX_CALLBACKS
)
359 return htonl(NFS4ERR_BADSLOT
);
361 slot
= tbl
->slots
+ args
->csa_slotid
;
362 dprintk("%s slot table seqid: %d\n", __func__
, slot
->seq_nr
);
365 if (likely(args
->csa_sequenceid
== slot
->seq_nr
+ 1)) {
371 if (args
->csa_sequenceid
== slot
->seq_nr
) {
372 dprintk("%s seqid %d is a replay\n",
373 __func__
, args
->csa_sequenceid
);
374 /* Signal process_op to set this error on next op */
375 if (args
->csa_cachethis
== 0)
376 return htonl(NFS4ERR_RETRY_UNCACHED_REP
);
378 /* The ca_maxresponsesize_cached is 0 with no DRC */
379 else if (args
->csa_cachethis
== 1)
380 return htonl(NFS4ERR_REP_TOO_BIG_TO_CACHE
);
384 if (args
->csa_sequenceid
== 1 && (slot
->seq_nr
+ 1) == 0) {
389 /* Misordered request */
390 return htonl(NFS4ERR_SEQ_MISORDERED
);
392 tbl
->highest_used_slotid
= args
->csa_slotid
;
393 return htonl(NFS4_OK
);
397 * For each referring call triple, check the session's slot table for
398 * a match. If the slot is in use and the sequence numbers match, the
399 * client is still waiting for a response to the original request.
401 static bool referring_call_exists(struct nfs_client
*clp
,
403 struct referring_call_list
*rclists
)
407 struct nfs4_session
*session
;
408 struct nfs4_slot_table
*tbl
;
409 struct referring_call_list
*rclist
;
410 struct referring_call
*ref
;
413 * XXX When client trunking is implemented, this becomes
414 * a session lookup from within the loop
416 session
= clp
->cl_session
;
417 tbl
= &session
->fc_slot_table
;
419 for (i
= 0; i
< nrclists
; i
++) {
420 rclist
= &rclists
[i
];
421 if (memcmp(session
->sess_id
.data
,
422 rclist
->rcl_sessionid
.data
,
423 NFS4_MAX_SESSIONID_LEN
) != 0)
426 for (j
= 0; j
< rclist
->rcl_nrefcalls
; j
++) {
427 ref
= &rclist
->rcl_refcalls
[j
];
429 dprintk("%s: sessionid %x:%x:%x:%x sequenceid %u "
430 "slotid %u\n", __func__
,
431 ((u32
*)&rclist
->rcl_sessionid
.data
)[0],
432 ((u32
*)&rclist
->rcl_sessionid
.data
)[1],
433 ((u32
*)&rclist
->rcl_sessionid
.data
)[2],
434 ((u32
*)&rclist
->rcl_sessionid
.data
)[3],
435 ref
->rc_sequenceid
, ref
->rc_slotid
);
437 spin_lock(&tbl
->slot_tbl_lock
);
438 status
= (test_bit(ref
->rc_slotid
, tbl
->used_slots
) &&
439 tbl
->slots
[ref
->rc_slotid
].seq_nr
==
441 spin_unlock(&tbl
->slot_tbl_lock
);
451 __be32
nfs4_callback_sequence(struct cb_sequenceargs
*args
,
452 struct cb_sequenceres
*res
,
453 struct cb_process_state
*cps
)
455 struct nfs4_slot_table
*tbl
;
456 struct nfs_client
*clp
;
458 __be32 status
= htonl(NFS4ERR_BADSESSION
);
460 clp
= nfs4_find_client_sessionid(cps
->net
, args
->csa_addr
, &args
->csa_sessionid
);
464 tbl
= &clp
->cl_session
->bc_slot_table
;
466 spin_lock(&tbl
->slot_tbl_lock
);
467 /* state manager is resetting the session */
468 if (test_bit(NFS4_SESSION_DRAINING
, &clp
->cl_session
->session_state
)) {
469 spin_unlock(&tbl
->slot_tbl_lock
);
470 status
= htonl(NFS4ERR_DELAY
);
471 /* Return NFS4ERR_BADSESSION if we're draining the session
472 * in order to reset it.
474 if (test_bit(NFS4CLNT_SESSION_RESET
, &clp
->cl_state
))
475 status
= htonl(NFS4ERR_BADSESSION
);
479 status
= validate_seqid(&clp
->cl_session
->bc_slot_table
, args
);
480 spin_unlock(&tbl
->slot_tbl_lock
);
484 cps
->slotid
= args
->csa_slotid
;
487 * Check for pending referring calls. If a match is found, a
488 * related callback was received before the response to the original
491 if (referring_call_exists(clp
, args
->csa_nrclists
, args
->csa_rclists
)) {
492 status
= htonl(NFS4ERR_DELAY
);
496 memcpy(&res
->csr_sessionid
, &args
->csa_sessionid
,
497 sizeof(res
->csr_sessionid
));
498 res
->csr_sequenceid
= args
->csa_sequenceid
;
499 res
->csr_slotid
= args
->csa_slotid
;
500 res
->csr_highestslotid
= NFS41_BC_MAX_CALLBACKS
- 1;
501 res
->csr_target_highestslotid
= NFS41_BC_MAX_CALLBACKS
- 1;
504 cps
->clp
= clp
; /* put in nfs4_callback_compound */
505 for (i
= 0; i
< args
->csa_nrclists
; i
++)
506 kfree(args
->csa_rclists
[i
].rcl_refcalls
);
507 kfree(args
->csa_rclists
);
509 if (status
== htonl(NFS4ERR_RETRY_UNCACHED_REP
)) {
510 cps
->drc_status
= status
;
513 res
->csr_status
= status
;
515 dprintk("%s: exit with status = %d res->csr_status %d\n", __func__
,
516 ntohl(status
), ntohl(res
->csr_status
));
521 validate_bitmap_values(unsigned long mask
)
523 return (mask
& ~RCA4_TYPE_MASK_ALL
) == 0;
526 __be32
nfs4_callback_recallany(struct cb_recallanyargs
*args
, void *dummy
,
527 struct cb_process_state
*cps
)
532 status
= cpu_to_be32(NFS4ERR_OP_NOT_IN_SESSION
);
533 if (!cps
->clp
) /* set in cb_sequence */
536 dprintk("NFS: RECALL_ANY callback request from %s\n",
537 rpc_peeraddr2str(cps
->clp
->cl_rpcclient
, RPC_DISPLAY_ADDR
));
539 status
= cpu_to_be32(NFS4ERR_INVAL
);
540 if (!validate_bitmap_values(args
->craa_type_mask
))
543 status
= cpu_to_be32(NFS4_OK
);
544 if (test_bit(RCA4_TYPE_MASK_RDATA_DLG
, (const unsigned long *)
545 &args
->craa_type_mask
))
547 if (test_bit(RCA4_TYPE_MASK_WDATA_DLG
, (const unsigned long *)
548 &args
->craa_type_mask
))
549 flags
|= FMODE_WRITE
;
550 if (test_bit(RCA4_TYPE_MASK_FILE_LAYOUT
, (const unsigned long *)
551 &args
->craa_type_mask
))
552 pnfs_recall_all_layouts(cps
->clp
);
554 nfs_expire_all_delegation_types(cps
->clp
, flags
);
556 dprintk("%s: exit with status = %d\n", __func__
, ntohl(status
));
560 /* Reduce the fore channel's max_slots to the target value */
561 __be32
nfs4_callback_recallslot(struct cb_recallslotargs
*args
, void *dummy
,
562 struct cb_process_state
*cps
)
564 struct nfs4_slot_table
*fc_tbl
;
567 status
= htonl(NFS4ERR_OP_NOT_IN_SESSION
);
568 if (!cps
->clp
) /* set in cb_sequence */
571 dprintk("NFS: CB_RECALL_SLOT request from %s target max slots %d\n",
572 rpc_peeraddr2str(cps
->clp
->cl_rpcclient
, RPC_DISPLAY_ADDR
),
573 args
->crsa_target_max_slots
);
575 fc_tbl
= &cps
->clp
->cl_session
->fc_slot_table
;
577 status
= htonl(NFS4ERR_BAD_HIGH_SLOT
);
578 if (args
->crsa_target_max_slots
> fc_tbl
->max_slots
||
579 args
->crsa_target_max_slots
< 1)
582 status
= htonl(NFS4_OK
);
583 if (args
->crsa_target_max_slots
== fc_tbl
->max_slots
)
586 fc_tbl
->target_max_slots
= args
->crsa_target_max_slots
;
587 nfs41_handle_recall_slot(cps
->clp
);
589 dprintk("%s: exit with status = %d\n", __func__
, ntohl(status
));
592 #endif /* CONFIG_NFS_V4_1 */