blob: a13d26ede254357d46bc1f24c7c404555048987f [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 Myklebust2446ab62012-03-01 17:00:56 -050011#include <linux/rcupdate.h>
Trond Myklebust4ce79712005-06-22 17:16:21 +000012#include "nfs4_fs.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070013#include "callback.h"
14#include "delegation.h"
David Howells24c8dbb2006-08-22 20:06:10 -040015#include "internal.h"
Fred Isaman43f1b3d2011-01-06 11:36:30 +000016#include "pnfs.h"
Trond Myklebust73e39aa2012-11-26 12:49:34 -050017#include "nfs4session.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070018
Chuck Lever1d98fe62007-12-10 14:57:23 -050019#ifdef NFS_DEBUG
Linus Torvalds1da177e2005-04-16 15:20:36 -070020#define NFSDBG_FACILITY NFSDBG_CALLBACK
Chuck Lever1d98fe62007-12-10 14:57:23 -050021#endif
Andy Adamsonc36fca52011-01-06 02:04:32 +000022
23__be32 nfs4_callback_getattr(struct cb_getattrargs *args,
24 struct cb_getattrres *res,
25 struct cb_process_state *cps)
Linus Torvalds1da177e2005-04-16 15:20:36 -070026{
Linus Torvalds1da177e2005-04-16 15:20:36 -070027 struct nfs_delegation *delegation;
28 struct nfs_inode *nfsi;
29 struct inode *inode;
Chuck Lever1d98fe62007-12-10 14:57:23 -050030
Andy Adamsonc36fca52011-01-06 02:04:32 +000031 res->status = htonl(NFS4ERR_OP_NOT_IN_SESSION);
32 if (!cps->clp) /* Always set for v4.0. Set in cb_sequence for v4.1 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070033 goto out;
Chuck Lever1d98fe62007-12-10 14:57:23 -050034
Andy Adamsonc36fca52011-01-06 02:04:32 +000035 res->bitmap[0] = res->bitmap[1] = 0;
36 res->status = htonl(NFS4ERR_BADHANDLE);
Chuck Lever1d98fe62007-12-10 14:57:23 -050037
Trond Myklebust2446ab62012-03-01 17:00:56 -050038 dprintk_rcu("NFS: GETATTR callback request from %s\n",
Andy Adamsonc36fca52011-01-06 02:04:32 +000039 rpc_peeraddr2str(cps->clp->cl_rpcclient, RPC_DISPLAY_ADDR));
40
41 inode = nfs_delegation_find_inode(cps->clp, &args->fh);
Linus Torvalds1da177e2005-04-16 15:20:36 -070042 if (inode == NULL)
Andy Adamsonc36fca52011-01-06 02:04:32 +000043 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -070044 nfsi = NFS_I(inode);
Trond Myklebust761fe932010-08-04 09:29:52 -040045 rcu_read_lock();
46 delegation = rcu_dereference(nfsi->delegation);
Linus Torvalds1da177e2005-04-16 15:20:36 -070047 if (delegation == NULL || (delegation->type & FMODE_WRITE) == 0)
48 goto out_iput;
49 res->size = i_size_read(inode);
Trond Myklebustbeb2a5e2006-01-03 09:55:37 +010050 res->change_attr = delegation->change_attr;
51 if (nfsi->npages != 0)
52 res->change_attr++;
Linus Torvalds1da177e2005-04-16 15:20:36 -070053 res->ctime = inode->i_ctime;
54 res->mtime = inode->i_mtime;
55 res->bitmap[0] = (FATTR4_WORD0_CHANGE|FATTR4_WORD0_SIZE) &
56 args->bitmap[0];
57 res->bitmap[1] = (FATTR4_WORD1_TIME_METADATA|FATTR4_WORD1_TIME_MODIFY) &
58 args->bitmap[1];
59 res->status = 0;
60out_iput:
Trond Myklebust761fe932010-08-04 09:29:52 -040061 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -070062 iput(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -070063out:
Harvey Harrison3110ff82008-05-02 13:42:44 -070064 dprintk("%s: exit with status = %d\n", __func__, ntohl(res->status));
Linus Torvalds1da177e2005-04-16 15:20:36 -070065 return res->status;
66}
67
Andy Adamsonc36fca52011-01-06 02:04:32 +000068__be32 nfs4_callback_recall(struct cb_recallargs *args, void *dummy,
69 struct cb_process_state *cps)
Linus Torvalds1da177e2005-04-16 15:20:36 -070070{
Linus Torvalds1da177e2005-04-16 15:20:36 -070071 struct inode *inode;
Al Viroe6f684f2006-10-19 23:28:50 -070072 __be32 res;
Linus Torvalds1da177e2005-04-16 15:20:36 -070073
Andy Adamsonc36fca52011-01-06 02:04:32 +000074 res = htonl(NFS4ERR_OP_NOT_IN_SESSION);
75 if (!cps->clp) /* Always set for v4.0. Set in cb_sequence for v4.1 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070076 goto out;
Chuck Lever1d98fe62007-12-10 14:57:23 -050077
Trond Myklebust2446ab62012-03-01 17:00:56 -050078 dprintk_rcu("NFS: RECALL callback request from %s\n",
Andy Adamsonc36fca52011-01-06 02:04:32 +000079 rpc_peeraddr2str(cps->clp->cl_rpcclient, RPC_DISPLAY_ADDR));
Chuck Lever1d98fe62007-12-10 14:57:23 -050080
Andy Adamsonc36fca52011-01-06 02:04:32 +000081 res = htonl(NFS4ERR_BADHANDLE);
82 inode = nfs_delegation_find_inode(cps->clp, &args->fh);
83 if (inode == NULL)
84 goto out;
85 /* Set up a helper thread to actually return the delegation */
86 switch (nfs_async_inode_return_delegation(inode, &args->stateid)) {
87 case 0:
88 res = 0;
89 break;
90 case -ENOENT:
Trond Myklebust8e663f02012-03-04 18:13:56 -050091 res = htonl(NFS4ERR_BAD_STATEID);
Andy Adamsonc36fca52011-01-06 02:04:32 +000092 break;
93 default:
94 res = htonl(NFS4ERR_RESOURCE);
95 }
96 iput(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -070097out:
Harvey Harrison3110ff82008-05-02 13:42:44 -070098 dprintk("%s: exit with status = %d\n", __func__, ntohl(res));
Linus Torvalds1da177e2005-04-16 15:20:36 -070099 return res;
100}
Benny Halevyd49433e2009-04-01 09:23:25 -0400101
102#if defined(CONFIG_NFS_V4_1)
103
Benny Halevyd36b7cf2012-01-22 16:03:39 +0200104/*
105 * Lookup a layout by filehandle.
106 *
107 * Note: gets a refcount on the layout hdr and on its respective inode.
108 * Caller must put the layout hdr and the inode.
109 *
110 * TODO: keep track of all layouts (and delegations) in a hash table
111 * hashed by filehandle.
112 */
113static struct pnfs_layout_hdr * get_layout_by_fh_locked(struct nfs_client *clp, struct nfs_fh *fh)
Fred Isaman43f1b3d2011-01-06 11:36:30 +0000114{
Weston Andros Adamson6382a442011-06-01 16:44:44 -0400115 struct nfs_server *server;
Fred Isaman43f1b3d2011-01-06 11:36:30 +0000116 struct inode *ino;
Benny Halevyd36b7cf2012-01-22 16:03:39 +0200117 struct pnfs_layout_hdr *lo;
Fred Isaman43f1b3d2011-01-06 11:36:30 +0000118
Weston Andros Adamson6382a442011-06-01 16:44:44 -0400119 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
120 list_for_each_entry(lo, &server->layouts, plh_layouts) {
Benny Halevyd36b7cf2012-01-22 16:03:39 +0200121 if (nfs_compare_fh(fh, &NFS_I(lo->plh_inode)->fh))
Weston Andros Adamson6382a442011-06-01 16:44:44 -0400122 continue;
123 ino = igrab(lo->plh_inode);
124 if (!ino)
125 continue;
Trond Myklebust9c626382012-09-20 17:31:43 -0400126 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);
130 iput(ino);
131 continue;
132 }
Trond Myklebust70c3bd22012-09-18 20:51:13 -0400133 pnfs_get_layout_hdr(lo);
Trond Myklebust9c626382012-09-20 17:31:43 -0400134 spin_unlock(&ino->i_lock);
Benny Halevyd36b7cf2012-01-22 16:03:39 +0200135 return lo;
Weston Andros Adamson6382a442011-06-01 16:44:44 -0400136 }
Fred Isaman43f1b3d2011-01-06 11:36:30 +0000137 }
Benny Halevyd36b7cf2012-01-22 16:03:39 +0200138
139 return NULL;
140}
141
142static struct pnfs_layout_hdr * get_layout_by_fh(struct nfs_client *clp, struct nfs_fh *fh)
143{
144 struct pnfs_layout_hdr *lo;
145
146 spin_lock(&clp->cl_lock);
147 rcu_read_lock();
148 lo = get_layout_by_fh_locked(clp, fh);
Weston Andros Adamson6382a442011-06-01 16:44:44 -0400149 rcu_read_unlock();
Fred Isaman43f1b3d2011-01-06 11:36:30 +0000150 spin_unlock(&clp->cl_lock);
Weston Andros Adamson6382a442011-06-01 16:44:44 -0400151
Benny Halevyd36b7cf2012-01-22 16:03:39 +0200152 return lo;
153}
154
155static u32 initiate_file_draining(struct nfs_client *clp,
156 struct cb_layoutrecallargs *args)
157{
158 struct inode *ino;
159 struct pnfs_layout_hdr *lo;
160 u32 rv = NFS4ERR_NOMATCHING_LAYOUT;
161 LIST_HEAD(free_me_list);
162
163 lo = get_layout_by_fh(clp, &args->cbl_fh);
164 if (!lo)
Fred Isaman43f1b3d2011-01-06 11:36:30 +0000165 return NFS4ERR_NOMATCHING_LAYOUT;
166
Benny Halevyd36b7cf2012-01-22 16:03:39 +0200167 ino = lo->plh_inode;
Fred Isaman43f1b3d2011-01-06 11:36:30 +0000168 spin_lock(&ino->i_lock);
169 if (test_bit(NFS_LAYOUT_BULK_RECALL, &lo->plh_flags) ||
Trond Myklebust49a85062012-09-18 20:43:31 -0400170 pnfs_mark_matching_lsegs_invalid(lo, &free_me_list,
Benny Halevy778b5502011-05-22 19:48:02 +0300171 &args->cbl_range))
Fred Isaman43f1b3d2011-01-06 11:36:30 +0000172 rv = NFS4ERR_DELAY;
173 else
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);
Trond Myklebust70c3bd22012-09-18 20:51:13 -0400178 pnfs_put_layout_hdr(lo);
Fred Isaman43f1b3d2011-01-06 11:36:30 +0000179 iput(ino);
180 return rv;
181}
182
183static u32 initiate_bulk_draining(struct nfs_client *clp,
184 struct cb_layoutrecallargs *args)
185{
Trond Myklebustfd9a8d72013-02-12 09:48:42 -0500186 int stat;
Fred Isaman43f1b3d2011-01-06 11:36:30 +0000187
Trond Myklebustfd9a8d72013-02-12 09:48:42 -0500188 if (args->cbl_recall_type == RETURN_FSID)
189 stat = pnfs_destroy_layouts_byfsid(clp, &args->cbl_fsid, true);
190 else
191 stat = pnfs_destroy_layouts_byclid(clp, true);
192 if (stat != 0)
193 return NFS4ERR_DELAY;
194 return NFS4ERR_NOMATCHING_LAYOUT;
Fred Isaman43f1b3d2011-01-06 11:36:30 +0000195}
196
197static u32 do_callback_layoutrecall(struct nfs_client *clp,
198 struct cb_layoutrecallargs *args)
199{
Trond Myklebust0cb32842012-03-01 11:17:50 -0500200 u32 res;
Fred Isaman43f1b3d2011-01-06 11:36:30 +0000201
202 dprintk("%s enter, type=%i\n", __func__, args->cbl_recall_type);
Fred Isaman43f1b3d2011-01-06 11:36:30 +0000203 if (args->cbl_recall_type == RETURN_FILE)
204 res = initiate_file_draining(clp, args);
205 else
206 res = initiate_bulk_draining(clp, args);
Fred Isaman43f1b3d2011-01-06 11:36:30 +0000207 dprintk("%s returning %i\n", __func__, res);
208 return res;
209
210}
211
Fred Isamanf2a62562011-01-06 11:36:29 +0000212__be32 nfs4_callback_layoutrecall(struct cb_layoutrecallargs *args,
213 void *dummy, struct cb_process_state *cps)
214{
Fred Isaman43f1b3d2011-01-06 11:36:30 +0000215 u32 res;
216
217 dprintk("%s: -->\n", __func__);
218
219 if (cps->clp)
220 res = do_callback_layoutrecall(cps->clp, args);
221 else
222 res = NFS4ERR_OP_NOT_IN_SESSION;
223
224 dprintk("%s: exit with status = %d\n", __func__, res);
225 return cpu_to_be32(res);
Fred Isamanf2a62562011-01-06 11:36:29 +0000226}
227
Alexandros Batsakis36840372011-01-06 11:36:31 +0000228static void pnfs_recall_all_layouts(struct nfs_client *clp)
229{
230 struct cb_layoutrecallargs args;
231
232 /* Pretend we got a CB_LAYOUTRECALL(ALL) */
233 memset(&args, 0, sizeof(args));
234 args.cbl_recall_type = RETURN_ALL;
235 /* FIXME we ignore errors, what should we do? */
236 do_callback_layoutrecall(clp, &args);
237}
238
Marc Eshel1be56832011-05-22 19:47:09 +0300239__be32 nfs4_callback_devicenotify(struct cb_devicenotifyargs *args,
240 void *dummy, struct cb_process_state *cps)
241{
242 int i;
243 __be32 res = 0;
244 struct nfs_client *clp = cps->clp;
245 struct nfs_server *server = NULL;
246
247 dprintk("%s: -->\n", __func__);
248
249 if (!clp) {
250 res = cpu_to_be32(NFS4ERR_OP_NOT_IN_SESSION);
251 goto out;
252 }
253
254 for (i = 0; i < args->ndevs; i++) {
255 struct cb_devicenotifyitem *dev = &args->devs[i];
256
257 if (!server ||
258 server->pnfs_curr_ld->id != dev->cbd_layout_type) {
259 rcu_read_lock();
260 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
261 if (server->pnfs_curr_ld &&
262 server->pnfs_curr_ld->id == dev->cbd_layout_type) {
263 rcu_read_unlock();
264 goto found;
265 }
266 rcu_read_unlock();
267 dprintk("%s: layout type %u not found\n",
268 __func__, dev->cbd_layout_type);
269 continue;
270 }
271
272 found:
273 if (dev->cbd_notify_type == NOTIFY_DEVICEID4_CHANGE)
274 dprintk("%s: NOTIFY_DEVICEID4_CHANGE not supported, "
275 "deleting instead\n", __func__);
Benny Halevy35c8bb52011-05-24 18:04:02 +0300276 nfs4_delete_deviceid(server->pnfs_curr_ld, clp, &dev->cbd_dev_id);
Marc Eshel1be56832011-05-22 19:47:09 +0300277 }
278
279out:
280 kfree(args->devs);
281 dprintk("%s: exit with status = %u\n",
282 __func__, be32_to_cpu(res));
283 return res;
284}
285
Ricardo Labiaga963891a2009-04-01 09:23:34 -0400286/*
Ricardo Labiaga68f3f902009-04-01 09:23:35 -0400287 * Validate the sequenceID sent by the server.
288 * Return success if the sequenceID is one more than what we last saw on
289 * this slot, accounting for wraparound. Increments the slot's sequence.
290 *
Andy Adamson49110962010-01-14 17:45:08 -0500291 * We don't yet implement a duplicate request cache, instead we set the
292 * back channel ca_maxresponsesize_cached to zero. This is OK for now
Ricardo Labiaga68f3f902009-04-01 09:23:35 -0400293 * since we only currently implement idempotent callbacks anyway.
294 *
295 * We have a single slot backchannel at this time, so we don't bother
296 * checking the used_slots bit array on the table. The lower layer guarantees
297 * a single outstanding callback request at a time.
298 */
Andy Adamson9733f0d2010-01-22 12:03:08 -0500299static __be32
Andy Adamsonb2f28bd2010-01-14 17:45:07 -0500300validate_seqid(struct nfs4_slot_table *tbl, struct cb_sequenceargs * args)
Ricardo Labiaga68f3f902009-04-01 09:23:35 -0400301{
302 struct nfs4_slot *slot;
303
304 dprintk("%s enter. slotid %d seqid %d\n",
Andy Adamsonb2f28bd2010-01-14 17:45:07 -0500305 __func__, args->csa_slotid, args->csa_sequenceid);
Ricardo Labiaga68f3f902009-04-01 09:23:35 -0400306
Andy Adamson61f2e512011-11-09 13:58:20 -0500307 if (args->csa_slotid >= NFS41_BC_MAX_CALLBACKS)
Ricardo Labiaga68f3f902009-04-01 09:23:35 -0400308 return htonl(NFS4ERR_BADSLOT);
309
Andy Adamsonb2f28bd2010-01-14 17:45:07 -0500310 slot = tbl->slots + args->csa_slotid;
Ricardo Labiaga68f3f902009-04-01 09:23:35 -0400311 dprintk("%s slot table seqid: %d\n", __func__, slot->seq_nr);
312
313 /* Normal */
Andy Adamsonb2f28bd2010-01-14 17:45:07 -0500314 if (likely(args->csa_sequenceid == slot->seq_nr + 1)) {
Ricardo Labiaga68f3f902009-04-01 09:23:35 -0400315 slot->seq_nr++;
Trond Myklebust55a67392011-08-02 14:46:29 -0400316 goto out_ok;
Ricardo Labiaga68f3f902009-04-01 09:23:35 -0400317 }
318
319 /* Replay */
Andy Adamsonb2f28bd2010-01-14 17:45:07 -0500320 if (args->csa_sequenceid == slot->seq_nr) {
Andy Adamson49110962010-01-14 17:45:08 -0500321 dprintk("%s seqid %d is a replay\n",
Andy Adamsonb2f28bd2010-01-14 17:45:07 -0500322 __func__, args->csa_sequenceid);
Andy Adamson49110962010-01-14 17:45:08 -0500323 /* Signal process_op to set this error on next op */
324 if (args->csa_cachethis == 0)
325 return htonl(NFS4ERR_RETRY_UNCACHED_REP);
326
327 /* The ca_maxresponsesize_cached is 0 with no DRC */
328 else if (args->csa_cachethis == 1)
329 return htonl(NFS4ERR_REP_TOO_BIG_TO_CACHE);
Ricardo Labiaga68f3f902009-04-01 09:23:35 -0400330 }
331
332 /* Wraparound */
Andy Adamsonb2f28bd2010-01-14 17:45:07 -0500333 if (args->csa_sequenceid == 1 && (slot->seq_nr + 1) == 0) {
Ricardo Labiaga68f3f902009-04-01 09:23:35 -0400334 slot->seq_nr = 1;
Trond Myklebust55a67392011-08-02 14:46:29 -0400335 goto out_ok;
Ricardo Labiaga68f3f902009-04-01 09:23:35 -0400336 }
337
338 /* Misordered request */
339 return htonl(NFS4ERR_SEQ_MISORDERED);
Trond Myklebust55a67392011-08-02 14:46:29 -0400340out_ok:
341 tbl->highest_used_slotid = args->csa_slotid;
342 return htonl(NFS4_OK);
Ricardo Labiaga68f3f902009-04-01 09:23:35 -0400343}
344
345/*
Mike Sagera7989c32010-01-19 12:54:40 -0500346 * For each referring call triple, check the session's slot table for
347 * a match. If the slot is in use and the sequence numbers match, the
348 * client is still waiting for a response to the original request.
349 */
350static bool referring_call_exists(struct nfs_client *clp,
351 uint32_t nrclists,
352 struct referring_call_list *rclists)
353{
354 bool status = 0;
355 int i, j;
356 struct nfs4_session *session;
357 struct nfs4_slot_table *tbl;
358 struct referring_call_list *rclist;
359 struct referring_call *ref;
360
361 /*
362 * XXX When client trunking is implemented, this becomes
363 * a session lookup from within the loop
364 */
365 session = clp->cl_session;
366 tbl = &session->fc_slot_table;
367
368 for (i = 0; i < nrclists; i++) {
369 rclist = &rclists[i];
370 if (memcmp(session->sess_id.data,
371 rclist->rcl_sessionid.data,
372 NFS4_MAX_SESSIONID_LEN) != 0)
373 continue;
374
375 for (j = 0; j < rclist->rcl_nrefcalls; j++) {
376 ref = &rclist->rcl_refcalls[j];
377
378 dprintk("%s: sessionid %x:%x:%x:%x sequenceid %u "
379 "slotid %u\n", __func__,
380 ((u32 *)&rclist->rcl_sessionid.data)[0],
381 ((u32 *)&rclist->rcl_sessionid.data)[1],
382 ((u32 *)&rclist->rcl_sessionid.data)[2],
383 ((u32 *)&rclist->rcl_sessionid.data)[3],
384 ref->rc_sequenceid, ref->rc_slotid);
385
386 spin_lock(&tbl->slot_tbl_lock);
387 status = (test_bit(ref->rc_slotid, tbl->used_slots) &&
388 tbl->slots[ref->rc_slotid].seq_nr ==
389 ref->rc_sequenceid);
390 spin_unlock(&tbl->slot_tbl_lock);
391 if (status)
392 goto out;
393 }
394 }
395
396out:
397 return status;
398}
399
Andy Adamson9733f0d2010-01-22 12:03:08 -0500400__be32 nfs4_callback_sequence(struct cb_sequenceargs *args,
Andy Adamsonc36fca52011-01-06 02:04:32 +0000401 struct cb_sequenceres *res,
402 struct cb_process_state *cps)
Benny Halevyd49433e2009-04-01 09:23:25 -0400403{
Trond Myklebust55a67392011-08-02 14:46:29 -0400404 struct nfs4_slot_table *tbl;
Ricardo Labiaga68f3f902009-04-01 09:23:35 -0400405 struct nfs_client *clp;
Andy Adamson9733f0d2010-01-22 12:03:08 -0500406 int i;
Andy Adamson778be232011-01-25 15:38:01 +0000407 __be32 status = htonl(NFS4ERR_BADSESSION);
Benny Halevyd49433e2009-04-01 09:23:25 -0400408
Stanislav Kinsburskyc7add9a2012-01-26 15:11:49 +0400409 clp = nfs4_find_client_sessionid(cps->net, args->csa_addr, &args->csa_sessionid);
Ricardo Labiaga68f3f902009-04-01 09:23:35 -0400410 if (clp == NULL)
411 goto out;
412
Trond Myklebust55a67392011-08-02 14:46:29 -0400413 tbl = &clp->cl_session->bc_slot_table;
414
415 spin_lock(&tbl->slot_tbl_lock);
Andy Adamson42acd022011-01-06 02:04:34 +0000416 /* state manager is resetting the session */
417 if (test_bit(NFS4_SESSION_DRAINING, &clp->cl_session->session_state)) {
Trond Myklebust55a67392011-08-02 14:46:29 -0400418 spin_unlock(&tbl->slot_tbl_lock);
419 status = htonl(NFS4ERR_DELAY);
Trond Myklebust910ac682011-08-02 14:46:52 -0400420 /* Return NFS4ERR_BADSESSION if we're draining the session
421 * in order to reset it.
422 */
423 if (test_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state))
424 status = htonl(NFS4ERR_BADSESSION);
Andy Adamson42acd022011-01-06 02:04:34 +0000425 goto out;
426 }
427
Andy Adamsonb2f28bd2010-01-14 17:45:07 -0500428 status = validate_seqid(&clp->cl_session->bc_slot_table, args);
Trond Myklebust55a67392011-08-02 14:46:29 -0400429 spin_unlock(&tbl->slot_tbl_lock);
Ricardo Labiaga68f3f902009-04-01 09:23:35 -0400430 if (status)
Andy Adamsonc36fca52011-01-06 02:04:32 +0000431 goto out;
Ricardo Labiaga68f3f902009-04-01 09:23:35 -0400432
Trond Myklebust55a67392011-08-02 14:46:29 -0400433 cps->slotid = args->csa_slotid;
434
Mike Sager72ce2b32010-01-19 12:54:41 -0500435 /*
436 * Check for pending referring calls. If a match is found, a
437 * related callback was received before the response to the original
438 * call.
439 */
440 if (referring_call_exists(clp, args->csa_nrclists, args->csa_rclists)) {
441 status = htonl(NFS4ERR_DELAY);
Andy Adamsonc36fca52011-01-06 02:04:32 +0000442 goto out;
Mike Sager72ce2b32010-01-19 12:54:41 -0500443 }
444
Benny Halevyd49433e2009-04-01 09:23:25 -0400445 memcpy(&res->csr_sessionid, &args->csa_sessionid,
446 sizeof(res->csr_sessionid));
447 res->csr_sequenceid = args->csa_sequenceid;
448 res->csr_slotid = args->csa_slotid;
449 res->csr_highestslotid = NFS41_BC_MAX_CALLBACKS - 1;
450 res->csr_target_highestslotid = NFS41_BC_MAX_CALLBACKS - 1;
451
Ricardo Labiaga68f3f902009-04-01 09:23:35 -0400452out:
Andy Adamson2c4cdf82011-01-25 15:38:02 +0000453 cps->clp = clp; /* put in nfs4_callback_compound */
Mike Sager72ce2b32010-01-19 12:54:41 -0500454 for (i = 0; i < args->csa_nrclists; i++)
455 kfree(args->csa_rclists[i].rcl_refcalls);
456 kfree(args->csa_rclists);
457
Andy Adamsonc36fca52011-01-06 02:04:32 +0000458 if (status == htonl(NFS4ERR_RETRY_UNCACHED_REP)) {
459 cps->drc_status = status;
460 status = 0;
461 } else
Andy Adamson49110962010-01-14 17:45:08 -0500462 res->csr_status = status;
Andy Adamsonc36fca52011-01-06 02:04:32 +0000463
Andy Adamson49110962010-01-14 17:45:08 -0500464 dprintk("%s: exit with status = %d res->csr_status %d\n", __func__,
465 ntohl(status), ntohl(res->csr_status));
466 return status;
Benny Halevyd49433e2009-04-01 09:23:25 -0400467}
468
Alexandros Batsakis36840372011-01-06 11:36:31 +0000469static bool
470validate_bitmap_values(unsigned long mask)
471{
472 return (mask & ~RCA4_TYPE_MASK_ALL) == 0;
473}
474
Andy Adamsonc36fca52011-01-06 02:04:32 +0000475__be32 nfs4_callback_recallany(struct cb_recallanyargs *args, void *dummy,
476 struct cb_process_state *cps)
Alexandros Batsakis31f09602009-12-05 13:27:02 -0500477{
Andy Adamson9733f0d2010-01-22 12:03:08 -0500478 __be32 status;
Alexandros Batsakis31f09602009-12-05 13:27:02 -0500479 fmode_t flags = 0;
480
Alexandros Batsakis36840372011-01-06 11:36:31 +0000481 status = cpu_to_be32(NFS4ERR_OP_NOT_IN_SESSION);
Andy Adamsonc36fca52011-01-06 02:04:32 +0000482 if (!cps->clp) /* set in cb_sequence */
Alexandros Batsakis31f09602009-12-05 13:27:02 -0500483 goto out;
484
Trond Myklebust2446ab62012-03-01 17:00:56 -0500485 dprintk_rcu("NFS: RECALL_ANY callback request from %s\n",
Andy Adamsonc36fca52011-01-06 02:04:32 +0000486 rpc_peeraddr2str(cps->clp->cl_rpcclient, RPC_DISPLAY_ADDR));
Alexandros Batsakis31f09602009-12-05 13:27:02 -0500487
Alexandros Batsakis36840372011-01-06 11:36:31 +0000488 status = cpu_to_be32(NFS4ERR_INVAL);
489 if (!validate_bitmap_values(args->craa_type_mask))
490 goto out;
491
492 status = cpu_to_be32(NFS4_OK);
Alexandros Batsakis31f09602009-12-05 13:27:02 -0500493 if (test_bit(RCA4_TYPE_MASK_RDATA_DLG, (const unsigned long *)
494 &args->craa_type_mask))
495 flags = FMODE_READ;
496 if (test_bit(RCA4_TYPE_MASK_WDATA_DLG, (const unsigned long *)
497 &args->craa_type_mask))
498 flags |= FMODE_WRITE;
Alexandros Batsakis36840372011-01-06 11:36:31 +0000499 if (test_bit(RCA4_TYPE_MASK_FILE_LAYOUT, (const unsigned long *)
500 &args->craa_type_mask))
501 pnfs_recall_all_layouts(cps->clp);
Alexandros Batsakis31f09602009-12-05 13:27:02 -0500502 if (flags)
Trond Myklebust826e0012013-04-03 19:27:52 -0400503 nfs_expire_unused_delegation_types(cps->clp, flags);
Alexandros Batsakis31f09602009-12-05 13:27:02 -0500504out:
505 dprintk("%s: exit with status = %d\n", __func__, ntohl(status));
506 return status;
507}
Andy Adamsonb9efa1b2010-01-20 16:06:27 -0500508
509/* Reduce the fore channel's max_slots to the target value */
Andy Adamsonc36fca52011-01-06 02:04:32 +0000510__be32 nfs4_callback_recallslot(struct cb_recallslotargs *args, void *dummy,
511 struct cb_process_state *cps)
Andy Adamsonb9efa1b2010-01-20 16:06:27 -0500512{
Andy Adamsonb9efa1b2010-01-20 16:06:27 -0500513 struct nfs4_slot_table *fc_tbl;
Andy Adamson9733f0d2010-01-22 12:03:08 -0500514 __be32 status;
Andy Adamsonb9efa1b2010-01-20 16:06:27 -0500515
516 status = htonl(NFS4ERR_OP_NOT_IN_SESSION);
Andy Adamsonc36fca52011-01-06 02:04:32 +0000517 if (!cps->clp) /* set in cb_sequence */
Andy Adamsonb9efa1b2010-01-20 16:06:27 -0500518 goto out;
519
Trond Myklebustd5fb4ce2012-11-20 20:24:02 -0500520 dprintk_rcu("NFS: CB_RECALL_SLOT request from %s target highest slotid %d\n",
Andy Adamsonc36fca52011-01-06 02:04:32 +0000521 rpc_peeraddr2str(cps->clp->cl_rpcclient, RPC_DISPLAY_ADDR),
Trond Myklebustd5fb4ce2012-11-20 20:24:02 -0500522 args->crsa_target_highest_slotid);
Andy Adamsonb9efa1b2010-01-20 16:06:27 -0500523
Andy Adamsonc36fca52011-01-06 02:04:32 +0000524 fc_tbl = &cps->clp->cl_session->fc_slot_table;
Andy Adamsonb9efa1b2010-01-20 16:06:27 -0500525
Andy Adamsonbae0ac02010-01-21 14:19:16 -0500526 status = htonl(NFS4_OK);
Andy Adamsonb9efa1b2010-01-20 16:06:27 -0500527
Trond Myklebustd5fb4ce2012-11-20 20:24:02 -0500528 nfs41_set_target_slotid(fc_tbl, args->crsa_target_highest_slotid);
Trond Myklebustac074832012-11-21 09:06:11 -0500529 nfs41_server_notify_target_slotid_update(cps->clp);
Andy Adamsonb9efa1b2010-01-20 16:06:27 -0500530out:
531 dprintk("%s: exit with status = %d\n", __func__, ntohl(status));
532 return status;
533}
Benny Halevyd49433e2009-04-01 09:23:25 -0400534#endif /* CONFIG_NFS_V4_1 */