blob: 89587573fe50660ee9a13ebc8890b94f1c4adfd8 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * linux/fs/nfs/callback_proc.c
3 *
4 * Copyright (C) 2004 Trond Myklebust
5 *
6 * NFSv4 callback procedures
7 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07008#include <linux/nfs4.h>
9#include <linux/nfs_fs.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090010#include <linux/slab.h>
Trond Myklebust4ce79712005-06-22 17:16:21 +000011#include "nfs4_fs.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070012#include "callback.h"
13#include "delegation.h"
David Howells24c8dbb2006-08-22 20:06:10 -040014#include "internal.h"
Fred Isaman43f1b3d2011-01-06 11:36:30 +000015#include "pnfs.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070016
Chuck Lever1d98fe62007-12-10 14:57:23 -050017#ifdef NFS_DEBUG
Linus Torvalds1da177e2005-04-16 15:20:36 -070018#define NFSDBG_FACILITY NFSDBG_CALLBACK
Chuck Lever1d98fe62007-12-10 14:57:23 -050019#endif
Andy Adamsonc36fca52011-01-06 02:04:32 +000020
21__be32 nfs4_callback_getattr(struct cb_getattrargs *args,
22 struct cb_getattrres *res,
23 struct cb_process_state *cps)
Linus Torvalds1da177e2005-04-16 15:20:36 -070024{
Linus Torvalds1da177e2005-04-16 15:20:36 -070025 struct nfs_delegation *delegation;
26 struct nfs_inode *nfsi;
27 struct inode *inode;
Chuck Lever1d98fe62007-12-10 14:57:23 -050028
Andy Adamsonc36fca52011-01-06 02:04:32 +000029 res->status = htonl(NFS4ERR_OP_NOT_IN_SESSION);
30 if (!cps->clp) /* Always set for v4.0. Set in cb_sequence for v4.1 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070031 goto out;
Chuck Lever1d98fe62007-12-10 14:57:23 -050032
Andy Adamsonc36fca52011-01-06 02:04:32 +000033 res->bitmap[0] = res->bitmap[1] = 0;
34 res->status = htonl(NFS4ERR_BADHANDLE);
Chuck Lever1d98fe62007-12-10 14:57:23 -050035
Andy Adamsonc36fca52011-01-06 02:04:32 +000036 dprintk("NFS: GETATTR callback request from %s\n",
37 rpc_peeraddr2str(cps->clp->cl_rpcclient, RPC_DISPLAY_ADDR));
38
39 inode = nfs_delegation_find_inode(cps->clp, &args->fh);
Linus Torvalds1da177e2005-04-16 15:20:36 -070040 if (inode == NULL)
Andy Adamsonc36fca52011-01-06 02:04:32 +000041 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -070042 nfsi = NFS_I(inode);
Trond Myklebust761fe932010-08-04 09:29:52 -040043 rcu_read_lock();
44 delegation = rcu_dereference(nfsi->delegation);
Linus Torvalds1da177e2005-04-16 15:20:36 -070045 if (delegation == NULL || (delegation->type & FMODE_WRITE) == 0)
46 goto out_iput;
47 res->size = i_size_read(inode);
Trond Myklebustbeb2a5e2006-01-03 09:55:37 +010048 res->change_attr = delegation->change_attr;
49 if (nfsi->npages != 0)
50 res->change_attr++;
Linus Torvalds1da177e2005-04-16 15:20:36 -070051 res->ctime = inode->i_ctime;
52 res->mtime = inode->i_mtime;
53 res->bitmap[0] = (FATTR4_WORD0_CHANGE|FATTR4_WORD0_SIZE) &
54 args->bitmap[0];
55 res->bitmap[1] = (FATTR4_WORD1_TIME_METADATA|FATTR4_WORD1_TIME_MODIFY) &
56 args->bitmap[1];
57 res->status = 0;
58out_iput:
Trond Myklebust761fe932010-08-04 09:29:52 -040059 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -070060 iput(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -070061out:
Harvey Harrison3110ff82008-05-02 13:42:44 -070062 dprintk("%s: exit with status = %d\n", __func__, ntohl(res->status));
Linus Torvalds1da177e2005-04-16 15:20:36 -070063 return res->status;
64}
65
Andy Adamsonc36fca52011-01-06 02:04:32 +000066__be32 nfs4_callback_recall(struct cb_recallargs *args, void *dummy,
67 struct cb_process_state *cps)
Linus Torvalds1da177e2005-04-16 15:20:36 -070068{
Linus Torvalds1da177e2005-04-16 15:20:36 -070069 struct inode *inode;
Al Viroe6f684f2006-10-19 23:28:50 -070070 __be32 res;
Linus Torvalds1da177e2005-04-16 15:20:36 -070071
Andy Adamsonc36fca52011-01-06 02:04:32 +000072 res = htonl(NFS4ERR_OP_NOT_IN_SESSION);
73 if (!cps->clp) /* Always set for v4.0. Set in cb_sequence for v4.1 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070074 goto out;
Chuck Lever1d98fe62007-12-10 14:57:23 -050075
76 dprintk("NFS: RECALL callback request from %s\n",
Andy Adamsonc36fca52011-01-06 02:04:32 +000077 rpc_peeraddr2str(cps->clp->cl_rpcclient, RPC_DISPLAY_ADDR));
Chuck Lever1d98fe62007-12-10 14:57:23 -050078
Andy Adamsonc36fca52011-01-06 02:04:32 +000079 res = htonl(NFS4ERR_BADHANDLE);
80 inode = nfs_delegation_find_inode(cps->clp, &args->fh);
81 if (inode == NULL)
82 goto out;
83 /* Set up a helper thread to actually return the delegation */
84 switch (nfs_async_inode_return_delegation(inode, &args->stateid)) {
85 case 0:
86 res = 0;
87 break;
88 case -ENOENT:
89 if (res != 0)
90 res = htonl(NFS4ERR_BAD_STATEID);
91 break;
92 default:
93 res = htonl(NFS4ERR_RESOURCE);
94 }
95 iput(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -070096out:
Harvey Harrison3110ff82008-05-02 13:42:44 -070097 dprintk("%s: exit with status = %d\n", __func__, ntohl(res));
Linus Torvalds1da177e2005-04-16 15:20:36 -070098 return res;
99}
Benny Halevyd49433e2009-04-01 09:23:25 -0400100
Alexandros Batsakis25976412009-12-05 13:48:55 -0500101int nfs4_validate_delegation_stateid(struct nfs_delegation *delegation, const nfs4_stateid *stateid)
102{
103 if (delegation == NULL || memcmp(delegation->stateid.data, stateid->data,
104 sizeof(delegation->stateid.data)) != 0)
105 return 0;
106 return 1;
107}
108
Benny Halevyd49433e2009-04-01 09:23:25 -0400109#if defined(CONFIG_NFS_V4_1)
110
Fred Isaman43f1b3d2011-01-06 11:36:30 +0000111static u32 initiate_file_draining(struct nfs_client *clp,
112 struct cb_layoutrecallargs *args)
113{
114 struct pnfs_layout_hdr *lo;
115 struct inode *ino;
116 bool found = false;
117 u32 rv = NFS4ERR_NOMATCHING_LAYOUT;
118 LIST_HEAD(free_me_list);
119
120 spin_lock(&clp->cl_lock);
121 list_for_each_entry(lo, &clp->cl_layouts, plh_layouts) {
122 if (nfs_compare_fh(&args->cbl_fh,
123 &NFS_I(lo->plh_inode)->fh))
124 continue;
125 ino = igrab(lo->plh_inode);
126 if (!ino)
127 continue;
128 found = true;
129 /* Without this, layout can be freed as soon
130 * as we release cl_lock.
131 */
132 get_layout_hdr(lo);
133 break;
134 }
135 spin_unlock(&clp->cl_lock);
136 if (!found)
137 return NFS4ERR_NOMATCHING_LAYOUT;
138
139 spin_lock(&ino->i_lock);
140 if (test_bit(NFS_LAYOUT_BULK_RECALL, &lo->plh_flags) ||
141 mark_matching_lsegs_invalid(lo, &free_me_list,
142 args->cbl_range.iomode))
143 rv = NFS4ERR_DELAY;
144 else
145 rv = NFS4ERR_NOMATCHING_LAYOUT;
146 pnfs_set_layout_stateid(lo, &args->cbl_stateid, true);
147 spin_unlock(&ino->i_lock);
148 pnfs_free_lseg_list(&free_me_list);
149 put_layout_hdr(lo);
150 iput(ino);
151 return rv;
152}
153
154static u32 initiate_bulk_draining(struct nfs_client *clp,
155 struct cb_layoutrecallargs *args)
156{
157 struct pnfs_layout_hdr *lo;
158 struct inode *ino;
159 u32 rv = NFS4ERR_NOMATCHING_LAYOUT;
160 struct pnfs_layout_hdr *tmp;
161 LIST_HEAD(recall_list);
162 LIST_HEAD(free_me_list);
163 struct pnfs_layout_range range = {
164 .iomode = IOMODE_ANY,
165 .offset = 0,
166 .length = NFS4_MAX_UINT64,
167 };
168
169 spin_lock(&clp->cl_lock);
170 list_for_each_entry(lo, &clp->cl_layouts, plh_layouts) {
171 if ((args->cbl_recall_type == RETURN_FSID) &&
172 memcmp(&NFS_SERVER(lo->plh_inode)->fsid,
173 &args->cbl_fsid, sizeof(struct nfs_fsid)))
174 continue;
175 if (!igrab(lo->plh_inode))
176 continue;
177 get_layout_hdr(lo);
178 BUG_ON(!list_empty(&lo->plh_bulk_recall));
179 list_add(&lo->plh_bulk_recall, &recall_list);
180 }
181 spin_unlock(&clp->cl_lock);
182 list_for_each_entry_safe(lo, tmp,
183 &recall_list, plh_bulk_recall) {
184 ino = lo->plh_inode;
185 spin_lock(&ino->i_lock);
186 set_bit(NFS_LAYOUT_BULK_RECALL, &lo->plh_flags);
187 if (mark_matching_lsegs_invalid(lo, &free_me_list, range.iomode))
188 rv = NFS4ERR_DELAY;
189 list_del_init(&lo->plh_bulk_recall);
190 spin_unlock(&ino->i_lock);
191 put_layout_hdr(lo);
192 iput(ino);
193 }
194 pnfs_free_lseg_list(&free_me_list);
195 return rv;
196}
197
198static u32 do_callback_layoutrecall(struct nfs_client *clp,
199 struct cb_layoutrecallargs *args)
200{
201 u32 res = NFS4ERR_DELAY;
202
203 dprintk("%s enter, type=%i\n", __func__, args->cbl_recall_type);
204 if (test_and_set_bit(NFS4CLNT_LAYOUTRECALL, &clp->cl_state))
205 goto out;
206 if (args->cbl_recall_type == RETURN_FILE)
207 res = initiate_file_draining(clp, args);
208 else
209 res = initiate_bulk_draining(clp, args);
210 clear_bit(NFS4CLNT_LAYOUTRECALL, &clp->cl_state);
211out:
212 dprintk("%s returning %i\n", __func__, res);
213 return res;
214
215}
216
Fred Isamanf2a62562011-01-06 11:36:29 +0000217__be32 nfs4_callback_layoutrecall(struct cb_layoutrecallargs *args,
218 void *dummy, struct cb_process_state *cps)
219{
Fred Isaman43f1b3d2011-01-06 11:36:30 +0000220 u32 res;
221
222 dprintk("%s: -->\n", __func__);
223
224 if (cps->clp)
225 res = do_callback_layoutrecall(cps->clp, args);
226 else
227 res = NFS4ERR_OP_NOT_IN_SESSION;
228
229 dprintk("%s: exit with status = %d\n", __func__, res);
230 return cpu_to_be32(res);
Fred Isamanf2a62562011-01-06 11:36:29 +0000231}
232
Alexandros Batsakis36840372011-01-06 11:36:31 +0000233static void pnfs_recall_all_layouts(struct nfs_client *clp)
234{
235 struct cb_layoutrecallargs args;
236
237 /* Pretend we got a CB_LAYOUTRECALL(ALL) */
238 memset(&args, 0, sizeof(args));
239 args.cbl_recall_type = RETURN_ALL;
240 /* FIXME we ignore errors, what should we do? */
241 do_callback_layoutrecall(clp, &args);
242}
243
Alexandros Batsakis25976412009-12-05 13:48:55 -0500244int nfs41_validate_delegation_stateid(struct nfs_delegation *delegation, const nfs4_stateid *stateid)
245{
246 if (delegation == NULL)
247 return 0;
248
Alexandros Batsakis94499252010-10-20 00:17:56 -0400249 if (stateid->stateid.seqid != 0)
Alexandros Batsakis25976412009-12-05 13:48:55 -0500250 return 0;
Alexandros Batsakis94499252010-10-20 00:17:56 -0400251 if (memcmp(&delegation->stateid.stateid.other,
252 &stateid->stateid.other,
253 NFS4_STATEID_OTHER_SIZE))
Alexandros Batsakis25976412009-12-05 13:48:55 -0500254 return 0;
255
256 return 1;
257}
258
Ricardo Labiaga963891a2009-04-01 09:23:34 -0400259/*
Ricardo Labiaga68f3f902009-04-01 09:23:35 -0400260 * Validate the sequenceID sent by the server.
261 * Return success if the sequenceID is one more than what we last saw on
262 * this slot, accounting for wraparound. Increments the slot's sequence.
263 *
Andy Adamson49110962010-01-14 17:45:08 -0500264 * We don't yet implement a duplicate request cache, instead we set the
265 * back channel ca_maxresponsesize_cached to zero. This is OK for now
Ricardo Labiaga68f3f902009-04-01 09:23:35 -0400266 * since we only currently implement idempotent callbacks anyway.
267 *
268 * We have a single slot backchannel at this time, so we don't bother
269 * checking the used_slots bit array on the table. The lower layer guarantees
270 * a single outstanding callback request at a time.
271 */
Andy Adamson9733f0d2010-01-22 12:03:08 -0500272static __be32
Andy Adamsonb2f28bd2010-01-14 17:45:07 -0500273validate_seqid(struct nfs4_slot_table *tbl, struct cb_sequenceargs * args)
Ricardo Labiaga68f3f902009-04-01 09:23:35 -0400274{
275 struct nfs4_slot *slot;
276
277 dprintk("%s enter. slotid %d seqid %d\n",
Andy Adamsonb2f28bd2010-01-14 17:45:07 -0500278 __func__, args->csa_slotid, args->csa_sequenceid);
Ricardo Labiaga68f3f902009-04-01 09:23:35 -0400279
Andy Adamsonb2f28bd2010-01-14 17:45:07 -0500280 if (args->csa_slotid > NFS41_BC_MAX_CALLBACKS)
Ricardo Labiaga68f3f902009-04-01 09:23:35 -0400281 return htonl(NFS4ERR_BADSLOT);
282
Andy Adamsonb2f28bd2010-01-14 17:45:07 -0500283 slot = tbl->slots + args->csa_slotid;
Ricardo Labiaga68f3f902009-04-01 09:23:35 -0400284 dprintk("%s slot table seqid: %d\n", __func__, slot->seq_nr);
285
286 /* Normal */
Andy Adamsonb2f28bd2010-01-14 17:45:07 -0500287 if (likely(args->csa_sequenceid == slot->seq_nr + 1)) {
Ricardo Labiaga68f3f902009-04-01 09:23:35 -0400288 slot->seq_nr++;
289 return htonl(NFS4_OK);
290 }
291
292 /* Replay */
Andy Adamsonb2f28bd2010-01-14 17:45:07 -0500293 if (args->csa_sequenceid == slot->seq_nr) {
Andy Adamson49110962010-01-14 17:45:08 -0500294 dprintk("%s seqid %d is a replay\n",
Andy Adamsonb2f28bd2010-01-14 17:45:07 -0500295 __func__, args->csa_sequenceid);
Andy Adamson49110962010-01-14 17:45:08 -0500296 /* Signal process_op to set this error on next op */
297 if (args->csa_cachethis == 0)
298 return htonl(NFS4ERR_RETRY_UNCACHED_REP);
299
300 /* The ca_maxresponsesize_cached is 0 with no DRC */
301 else if (args->csa_cachethis == 1)
302 return htonl(NFS4ERR_REP_TOO_BIG_TO_CACHE);
Ricardo Labiaga68f3f902009-04-01 09:23:35 -0400303 }
304
305 /* Wraparound */
Andy Adamsonb2f28bd2010-01-14 17:45:07 -0500306 if (args->csa_sequenceid == 1 && (slot->seq_nr + 1) == 0) {
Ricardo Labiaga68f3f902009-04-01 09:23:35 -0400307 slot->seq_nr = 1;
308 return htonl(NFS4_OK);
309 }
310
311 /* Misordered request */
312 return htonl(NFS4ERR_SEQ_MISORDERED);
313}
314
315/*
Mike Sagera7989c32010-01-19 12:54:40 -0500316 * For each referring call triple, check the session's slot table for
317 * a match. If the slot is in use and the sequence numbers match, the
318 * client is still waiting for a response to the original request.
319 */
320static bool referring_call_exists(struct nfs_client *clp,
321 uint32_t nrclists,
322 struct referring_call_list *rclists)
323{
324 bool status = 0;
325 int i, j;
326 struct nfs4_session *session;
327 struct nfs4_slot_table *tbl;
328 struct referring_call_list *rclist;
329 struct referring_call *ref;
330
331 /*
332 * XXX When client trunking is implemented, this becomes
333 * a session lookup from within the loop
334 */
335 session = clp->cl_session;
336 tbl = &session->fc_slot_table;
337
338 for (i = 0; i < nrclists; i++) {
339 rclist = &rclists[i];
340 if (memcmp(session->sess_id.data,
341 rclist->rcl_sessionid.data,
342 NFS4_MAX_SESSIONID_LEN) != 0)
343 continue;
344
345 for (j = 0; j < rclist->rcl_nrefcalls; j++) {
346 ref = &rclist->rcl_refcalls[j];
347
348 dprintk("%s: sessionid %x:%x:%x:%x sequenceid %u "
349 "slotid %u\n", __func__,
350 ((u32 *)&rclist->rcl_sessionid.data)[0],
351 ((u32 *)&rclist->rcl_sessionid.data)[1],
352 ((u32 *)&rclist->rcl_sessionid.data)[2],
353 ((u32 *)&rclist->rcl_sessionid.data)[3],
354 ref->rc_sequenceid, ref->rc_slotid);
355
356 spin_lock(&tbl->slot_tbl_lock);
357 status = (test_bit(ref->rc_slotid, tbl->used_slots) &&
358 tbl->slots[ref->rc_slotid].seq_nr ==
359 ref->rc_sequenceid);
360 spin_unlock(&tbl->slot_tbl_lock);
361 if (status)
362 goto out;
363 }
364 }
365
366out:
367 return status;
368}
369
Andy Adamson9733f0d2010-01-22 12:03:08 -0500370__be32 nfs4_callback_sequence(struct cb_sequenceargs *args,
Andy Adamsonc36fca52011-01-06 02:04:32 +0000371 struct cb_sequenceres *res,
372 struct cb_process_state *cps)
Benny Halevyd49433e2009-04-01 09:23:25 -0400373{
Ricardo Labiaga68f3f902009-04-01 09:23:35 -0400374 struct nfs_client *clp;
Andy Adamson9733f0d2010-01-22 12:03:08 -0500375 int i;
Andy Adamson778be232011-01-25 15:38:01 +0000376 __be32 status = htonl(NFS4ERR_BADSESSION);
Benny Halevyd49433e2009-04-01 09:23:25 -0400377
Andy Adamsonc36fca52011-01-06 02:04:32 +0000378 cps->clp = NULL;
379
Andy Adamson778be232011-01-25 15:38:01 +0000380 clp = nfs4_find_client_sessionid(args->csa_addr, &args->csa_sessionid);
Ricardo Labiaga68f3f902009-04-01 09:23:35 -0400381 if (clp == NULL)
382 goto out;
383
Andy Adamson42acd022011-01-06 02:04:34 +0000384 /* state manager is resetting the session */
385 if (test_bit(NFS4_SESSION_DRAINING, &clp->cl_session->session_state)) {
386 status = NFS4ERR_DELAY;
387 goto out;
388 }
389
Andy Adamsonb2f28bd2010-01-14 17:45:07 -0500390 status = validate_seqid(&clp->cl_session->bc_slot_table, args);
Ricardo Labiaga68f3f902009-04-01 09:23:35 -0400391 if (status)
Andy Adamsonc36fca52011-01-06 02:04:32 +0000392 goto out;
Ricardo Labiaga68f3f902009-04-01 09:23:35 -0400393
Mike Sager72ce2b32010-01-19 12:54:41 -0500394 /*
395 * Check for pending referring calls. If a match is found, a
396 * related callback was received before the response to the original
397 * call.
398 */
399 if (referring_call_exists(clp, args->csa_nrclists, args->csa_rclists)) {
400 status = htonl(NFS4ERR_DELAY);
Andy Adamsonc36fca52011-01-06 02:04:32 +0000401 goto out;
Mike Sager72ce2b32010-01-19 12:54:41 -0500402 }
403
Benny Halevyd49433e2009-04-01 09:23:25 -0400404 memcpy(&res->csr_sessionid, &args->csa_sessionid,
405 sizeof(res->csr_sessionid));
406 res->csr_sequenceid = args->csa_sequenceid;
407 res->csr_slotid = args->csa_slotid;
408 res->csr_highestslotid = NFS41_BC_MAX_CALLBACKS - 1;
409 res->csr_target_highestslotid = NFS41_BC_MAX_CALLBACKS - 1;
Andy Adamson42acd022011-01-06 02:04:34 +0000410 nfs4_cb_take_slot(clp);
Benny Halevyd49433e2009-04-01 09:23:25 -0400411
Ricardo Labiaga68f3f902009-04-01 09:23:35 -0400412out:
Andy Adamson2c4cdf82011-01-25 15:38:02 +0000413 cps->clp = clp; /* put in nfs4_callback_compound */
Mike Sager72ce2b32010-01-19 12:54:41 -0500414 for (i = 0; i < args->csa_nrclists; i++)
415 kfree(args->csa_rclists[i].rcl_refcalls);
416 kfree(args->csa_rclists);
417
Andy Adamsonc36fca52011-01-06 02:04:32 +0000418 if (status == htonl(NFS4ERR_RETRY_UNCACHED_REP)) {
419 cps->drc_status = status;
420 status = 0;
421 } else
Andy Adamson49110962010-01-14 17:45:08 -0500422 res->csr_status = status;
Andy Adamsonc36fca52011-01-06 02:04:32 +0000423
Andy Adamson49110962010-01-14 17:45:08 -0500424 dprintk("%s: exit with status = %d res->csr_status %d\n", __func__,
425 ntohl(status), ntohl(res->csr_status));
426 return status;
Benny Halevyd49433e2009-04-01 09:23:25 -0400427}
428
Alexandros Batsakis36840372011-01-06 11:36:31 +0000429static bool
430validate_bitmap_values(unsigned long mask)
431{
432 return (mask & ~RCA4_TYPE_MASK_ALL) == 0;
433}
434
Andy Adamsonc36fca52011-01-06 02:04:32 +0000435__be32 nfs4_callback_recallany(struct cb_recallanyargs *args, void *dummy,
436 struct cb_process_state *cps)
Alexandros Batsakis31f09602009-12-05 13:27:02 -0500437{
Andy Adamson9733f0d2010-01-22 12:03:08 -0500438 __be32 status;
Alexandros Batsakis31f09602009-12-05 13:27:02 -0500439 fmode_t flags = 0;
440
Alexandros Batsakis36840372011-01-06 11:36:31 +0000441 status = cpu_to_be32(NFS4ERR_OP_NOT_IN_SESSION);
Andy Adamsonc36fca52011-01-06 02:04:32 +0000442 if (!cps->clp) /* set in cb_sequence */
Alexandros Batsakis31f09602009-12-05 13:27:02 -0500443 goto out;
444
445 dprintk("NFS: RECALL_ANY callback request from %s\n",
Andy Adamsonc36fca52011-01-06 02:04:32 +0000446 rpc_peeraddr2str(cps->clp->cl_rpcclient, RPC_DISPLAY_ADDR));
Alexandros Batsakis31f09602009-12-05 13:27:02 -0500447
Alexandros Batsakis36840372011-01-06 11:36:31 +0000448 status = cpu_to_be32(NFS4ERR_INVAL);
449 if (!validate_bitmap_values(args->craa_type_mask))
450 goto out;
451
452 status = cpu_to_be32(NFS4_OK);
Alexandros Batsakis31f09602009-12-05 13:27:02 -0500453 if (test_bit(RCA4_TYPE_MASK_RDATA_DLG, (const unsigned long *)
454 &args->craa_type_mask))
455 flags = FMODE_READ;
456 if (test_bit(RCA4_TYPE_MASK_WDATA_DLG, (const unsigned long *)
457 &args->craa_type_mask))
458 flags |= FMODE_WRITE;
Alexandros Batsakis36840372011-01-06 11:36:31 +0000459 if (test_bit(RCA4_TYPE_MASK_FILE_LAYOUT, (const unsigned long *)
460 &args->craa_type_mask))
461 pnfs_recall_all_layouts(cps->clp);
Alexandros Batsakis31f09602009-12-05 13:27:02 -0500462 if (flags)
Andy Adamsonc36fca52011-01-06 02:04:32 +0000463 nfs_expire_all_delegation_types(cps->clp, flags);
Alexandros Batsakis31f09602009-12-05 13:27:02 -0500464out:
465 dprintk("%s: exit with status = %d\n", __func__, ntohl(status));
466 return status;
467}
Andy Adamsonb9efa1b2010-01-20 16:06:27 -0500468
469/* Reduce the fore channel's max_slots to the target value */
Andy Adamsonc36fca52011-01-06 02:04:32 +0000470__be32 nfs4_callback_recallslot(struct cb_recallslotargs *args, void *dummy,
471 struct cb_process_state *cps)
Andy Adamsonb9efa1b2010-01-20 16:06:27 -0500472{
Andy Adamsonb9efa1b2010-01-20 16:06:27 -0500473 struct nfs4_slot_table *fc_tbl;
Andy Adamson9733f0d2010-01-22 12:03:08 -0500474 __be32 status;
Andy Adamsonb9efa1b2010-01-20 16:06:27 -0500475
476 status = htonl(NFS4ERR_OP_NOT_IN_SESSION);
Andy Adamsonc36fca52011-01-06 02:04:32 +0000477 if (!cps->clp) /* set in cb_sequence */
Andy Adamsonb9efa1b2010-01-20 16:06:27 -0500478 goto out;
479
480 dprintk("NFS: CB_RECALL_SLOT request from %s target max slots %d\n",
Andy Adamsonc36fca52011-01-06 02:04:32 +0000481 rpc_peeraddr2str(cps->clp->cl_rpcclient, RPC_DISPLAY_ADDR),
Andy Adamsonb9efa1b2010-01-20 16:06:27 -0500482 args->crsa_target_max_slots);
483
Andy Adamsonc36fca52011-01-06 02:04:32 +0000484 fc_tbl = &cps->clp->cl_session->fc_slot_table;
Andy Adamsonb9efa1b2010-01-20 16:06:27 -0500485
486 status = htonl(NFS4ERR_BAD_HIGH_SLOT);
Andy Adamsonbae0ac02010-01-21 14:19:16 -0500487 if (args->crsa_target_max_slots > fc_tbl->max_slots ||
Andy Adamsonb9efa1b2010-01-20 16:06:27 -0500488 args->crsa_target_max_slots < 1)
Andy Adamsonc36fca52011-01-06 02:04:32 +0000489 goto out;
Andy Adamsonbae0ac02010-01-21 14:19:16 -0500490
491 status = htonl(NFS4_OK);
492 if (args->crsa_target_max_slots == fc_tbl->max_slots)
Andy Adamsonc36fca52011-01-06 02:04:32 +0000493 goto out;
Andy Adamsonb9efa1b2010-01-20 16:06:27 -0500494
495 fc_tbl->target_max_slots = args->crsa_target_max_slots;
Andy Adamsonc36fca52011-01-06 02:04:32 +0000496 nfs41_handle_recall_slot(cps->clp);
Andy Adamsonb9efa1b2010-01-20 16:06:27 -0500497out:
498 dprintk("%s: exit with status = %d\n", __func__, ntohl(status));
499 return status;
500}
Benny Halevyd49433e2009-04-01 09:23:25 -0400501#endif /* CONFIG_NFS_V4_1 */