blob: 930d10fecdaff8632dc35869c3695fc8397e8d7a [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"
Linus Torvalds1da177e2005-04-16 15:20:36 -070015
Chuck Lever1d98fe62007-12-10 14:57:23 -050016#ifdef NFS_DEBUG
Linus Torvalds1da177e2005-04-16 15:20:36 -070017#define NFSDBG_FACILITY NFSDBG_CALLBACK
Chuck Lever1d98fe62007-12-10 14:57:23 -050018#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -070019
Al Viroe6f684f2006-10-19 23:28:50 -070020__be32 nfs4_callback_getattr(struct cb_getattrargs *args, struct cb_getattrres *res)
Linus Torvalds1da177e2005-04-16 15:20:36 -070021{
David Howellsadfa6f92006-08-22 20:06:08 -040022 struct nfs_client *clp;
Linus Torvalds1da177e2005-04-16 15:20:36 -070023 struct nfs_delegation *delegation;
24 struct nfs_inode *nfsi;
25 struct inode *inode;
Chuck Lever1d98fe62007-12-10 14:57:23 -050026
Linus Torvalds1da177e2005-04-16 15:20:36 -070027 res->bitmap[0] = res->bitmap[1] = 0;
28 res->status = htonl(NFS4ERR_BADHANDLE);
Chuck Leverff052642007-12-10 14:58:44 -050029 clp = nfs_find_client(args->addr, 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -070030 if (clp == NULL)
31 goto out;
Chuck Lever1d98fe62007-12-10 14:57:23 -050032
33 dprintk("NFS: GETATTR callback request from %s\n",
34 rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_ADDR));
35
Linus Torvalds1da177e2005-04-16 15:20:36 -070036 inode = nfs_delegation_find_inode(clp, &args->fh);
37 if (inode == NULL)
38 goto out_putclient;
39 nfsi = NFS_I(inode);
Trond Myklebust761fe932010-08-04 09:29:52 -040040 rcu_read_lock();
41 delegation = rcu_dereference(nfsi->delegation);
Linus Torvalds1da177e2005-04-16 15:20:36 -070042 if (delegation == NULL || (delegation->type & FMODE_WRITE) == 0)
43 goto out_iput;
44 res->size = i_size_read(inode);
Trond Myklebustbeb2a5e2006-01-03 09:55:37 +010045 res->change_attr = delegation->change_attr;
46 if (nfsi->npages != 0)
47 res->change_attr++;
Linus Torvalds1da177e2005-04-16 15:20:36 -070048 res->ctime = inode->i_ctime;
49 res->mtime = inode->i_mtime;
50 res->bitmap[0] = (FATTR4_WORD0_CHANGE|FATTR4_WORD0_SIZE) &
51 args->bitmap[0];
52 res->bitmap[1] = (FATTR4_WORD1_TIME_METADATA|FATTR4_WORD1_TIME_MODIFY) &
53 args->bitmap[1];
54 res->status = 0;
55out_iput:
Trond Myklebust761fe932010-08-04 09:29:52 -040056 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -070057 iput(inode);
58out_putclient:
David Howells24c8dbb2006-08-22 20:06:10 -040059 nfs_put_client(clp);
Linus Torvalds1da177e2005-04-16 15:20:36 -070060out:
Harvey Harrison3110ff82008-05-02 13:42:44 -070061 dprintk("%s: exit with status = %d\n", __func__, ntohl(res->status));
Linus Torvalds1da177e2005-04-16 15:20:36 -070062 return res->status;
63}
64
Al Viroe6f684f2006-10-19 23:28:50 -070065__be32 nfs4_callback_recall(struct cb_recallargs *args, void *dummy)
Linus Torvalds1da177e2005-04-16 15:20:36 -070066{
David Howellsadfa6f92006-08-22 20:06:08 -040067 struct nfs_client *clp;
Linus Torvalds1da177e2005-04-16 15:20:36 -070068 struct inode *inode;
Al Viroe6f684f2006-10-19 23:28:50 -070069 __be32 res;
Linus Torvalds1da177e2005-04-16 15:20:36 -070070
71 res = htonl(NFS4ERR_BADHANDLE);
Chuck Leverff052642007-12-10 14:58:44 -050072 clp = nfs_find_client(args->addr, 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -070073 if (clp == NULL)
74 goto out;
Chuck Lever1d98fe62007-12-10 14:57:23 -050075
76 dprintk("NFS: RECALL callback request from %s\n",
77 rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_ADDR));
78
Trond Myklebust3fbd67a2008-01-26 01:06:40 -050079 do {
80 struct nfs_client *prev = clp;
81
82 inode = nfs_delegation_find_inode(clp, &args->fh);
83 if (inode != NULL) {
84 /* Set up a helper thread to actually return the delegation */
Trond Myklebuste047a102010-06-16 09:52:27 -040085 switch (nfs_async_inode_return_delegation(inode, &args->stateid)) {
Trond Myklebust3fbd67a2008-01-26 01:06:40 -050086 case 0:
87 res = 0;
88 break;
89 case -ENOENT:
90 if (res != 0)
91 res = htonl(NFS4ERR_BAD_STATEID);
92 break;
93 default:
94 res = htonl(NFS4ERR_RESOURCE);
95 }
96 iput(inode);
97 }
98 clp = nfs_find_client_next(prev);
99 nfs_put_client(prev);
100 } while (clp != NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101out:
Harvey Harrison3110ff82008-05-02 13:42:44 -0700102 dprintk("%s: exit with status = %d\n", __func__, ntohl(res));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103 return res;
104}
Benny Halevyd49433e2009-04-01 09:23:25 -0400105
Alexandros Batsakis25976412009-12-05 13:48:55 -0500106int nfs4_validate_delegation_stateid(struct nfs_delegation *delegation, const nfs4_stateid *stateid)
107{
108 if (delegation == NULL || memcmp(delegation->stateid.data, stateid->data,
109 sizeof(delegation->stateid.data)) != 0)
110 return 0;
111 return 1;
112}
113
Benny Halevyd49433e2009-04-01 09:23:25 -0400114#if defined(CONFIG_NFS_V4_1)
115
Alexandros Batsakis25976412009-12-05 13:48:55 -0500116int nfs41_validate_delegation_stateid(struct nfs_delegation *delegation, const nfs4_stateid *stateid)
117{
118 if (delegation == NULL)
119 return 0;
120
121 /* seqid is 4-bytes long */
122 if (((u32 *) &stateid->data)[0] != 0)
123 return 0;
124 if (memcmp(&delegation->stateid.data[4], &stateid->data[4],
125 sizeof(stateid->data)-4))
126 return 0;
127
128 return 1;
129}
130
Ricardo Labiaga963891a2009-04-01 09:23:34 -0400131/*
Ricardo Labiaga68f3f902009-04-01 09:23:35 -0400132 * Validate the sequenceID sent by the server.
133 * Return success if the sequenceID is one more than what we last saw on
134 * this slot, accounting for wraparound. Increments the slot's sequence.
135 *
Andy Adamson49110962010-01-14 17:45:08 -0500136 * We don't yet implement a duplicate request cache, instead we set the
137 * back channel ca_maxresponsesize_cached to zero. This is OK for now
Ricardo Labiaga68f3f902009-04-01 09:23:35 -0400138 * since we only currently implement idempotent callbacks anyway.
139 *
140 * We have a single slot backchannel at this time, so we don't bother
141 * checking the used_slots bit array on the table. The lower layer guarantees
142 * a single outstanding callback request at a time.
143 */
Andy Adamson9733f0d2010-01-22 12:03:08 -0500144static __be32
Andy Adamsonb2f28bd2010-01-14 17:45:07 -0500145validate_seqid(struct nfs4_slot_table *tbl, struct cb_sequenceargs * args)
Ricardo Labiaga68f3f902009-04-01 09:23:35 -0400146{
147 struct nfs4_slot *slot;
148
149 dprintk("%s enter. slotid %d seqid %d\n",
Andy Adamsonb2f28bd2010-01-14 17:45:07 -0500150 __func__, args->csa_slotid, args->csa_sequenceid);
Ricardo Labiaga68f3f902009-04-01 09:23:35 -0400151
Andy Adamsonb2f28bd2010-01-14 17:45:07 -0500152 if (args->csa_slotid > NFS41_BC_MAX_CALLBACKS)
Ricardo Labiaga68f3f902009-04-01 09:23:35 -0400153 return htonl(NFS4ERR_BADSLOT);
154
Andy Adamsonb2f28bd2010-01-14 17:45:07 -0500155 slot = tbl->slots + args->csa_slotid;
Ricardo Labiaga68f3f902009-04-01 09:23:35 -0400156 dprintk("%s slot table seqid: %d\n", __func__, slot->seq_nr);
157
158 /* Normal */
Andy Adamsonb2f28bd2010-01-14 17:45:07 -0500159 if (likely(args->csa_sequenceid == slot->seq_nr + 1)) {
Ricardo Labiaga68f3f902009-04-01 09:23:35 -0400160 slot->seq_nr++;
161 return htonl(NFS4_OK);
162 }
163
164 /* Replay */
Andy Adamsonb2f28bd2010-01-14 17:45:07 -0500165 if (args->csa_sequenceid == slot->seq_nr) {
Andy Adamson49110962010-01-14 17:45:08 -0500166 dprintk("%s seqid %d is a replay\n",
Andy Adamsonb2f28bd2010-01-14 17:45:07 -0500167 __func__, args->csa_sequenceid);
Andy Adamson49110962010-01-14 17:45:08 -0500168 /* Signal process_op to set this error on next op */
169 if (args->csa_cachethis == 0)
170 return htonl(NFS4ERR_RETRY_UNCACHED_REP);
171
172 /* The ca_maxresponsesize_cached is 0 with no DRC */
173 else if (args->csa_cachethis == 1)
174 return htonl(NFS4ERR_REP_TOO_BIG_TO_CACHE);
Ricardo Labiaga68f3f902009-04-01 09:23:35 -0400175 }
176
177 /* Wraparound */
Andy Adamsonb2f28bd2010-01-14 17:45:07 -0500178 if (args->csa_sequenceid == 1 && (slot->seq_nr + 1) == 0) {
Ricardo Labiaga68f3f902009-04-01 09:23:35 -0400179 slot->seq_nr = 1;
180 return htonl(NFS4_OK);
181 }
182
183 /* Misordered request */
184 return htonl(NFS4ERR_SEQ_MISORDERED);
185}
186
187/*
Ricardo Labiaga963891a2009-04-01 09:23:34 -0400188 * Returns a pointer to a held 'struct nfs_client' that matches the server's
189 * address, major version number, and session ID. It is the caller's
190 * responsibility to release the returned reference.
191 *
192 * Returns NULL if there are no connections with sessions, or if no session
193 * matches the one of interest.
194 */
195 static struct nfs_client *find_client_with_session(
196 const struct sockaddr *addr, u32 nfsversion,
197 struct nfs4_sessionid *sessionid)
198{
199 struct nfs_client *clp;
200
201 clp = nfs_find_client(addr, 4);
202 if (clp == NULL)
203 return NULL;
204
205 do {
206 struct nfs_client *prev = clp;
207
208 if (clp->cl_session != NULL) {
209 if (memcmp(clp->cl_session->sess_id.data,
210 sessionid->data,
211 NFS4_MAX_SESSIONID_LEN) == 0) {
212 /* Returns a held reference to clp */
213 return clp;
214 }
215 }
216 clp = nfs_find_client_next(prev);
217 nfs_put_client(prev);
218 } while (clp != NULL);
219
220 return NULL;
221}
222
Mike Sagera7989c32010-01-19 12:54:40 -0500223/*
224 * For each referring call triple, check the session's slot table for
225 * a match. If the slot is in use and the sequence numbers match, the
226 * client is still waiting for a response to the original request.
227 */
228static bool referring_call_exists(struct nfs_client *clp,
229 uint32_t nrclists,
230 struct referring_call_list *rclists)
231{
232 bool status = 0;
233 int i, j;
234 struct nfs4_session *session;
235 struct nfs4_slot_table *tbl;
236 struct referring_call_list *rclist;
237 struct referring_call *ref;
238
239 /*
240 * XXX When client trunking is implemented, this becomes
241 * a session lookup from within the loop
242 */
243 session = clp->cl_session;
244 tbl = &session->fc_slot_table;
245
246 for (i = 0; i < nrclists; i++) {
247 rclist = &rclists[i];
248 if (memcmp(session->sess_id.data,
249 rclist->rcl_sessionid.data,
250 NFS4_MAX_SESSIONID_LEN) != 0)
251 continue;
252
253 for (j = 0; j < rclist->rcl_nrefcalls; j++) {
254 ref = &rclist->rcl_refcalls[j];
255
256 dprintk("%s: sessionid %x:%x:%x:%x sequenceid %u "
257 "slotid %u\n", __func__,
258 ((u32 *)&rclist->rcl_sessionid.data)[0],
259 ((u32 *)&rclist->rcl_sessionid.data)[1],
260 ((u32 *)&rclist->rcl_sessionid.data)[2],
261 ((u32 *)&rclist->rcl_sessionid.data)[3],
262 ref->rc_sequenceid, ref->rc_slotid);
263
264 spin_lock(&tbl->slot_tbl_lock);
265 status = (test_bit(ref->rc_slotid, tbl->used_slots) &&
266 tbl->slots[ref->rc_slotid].seq_nr ==
267 ref->rc_sequenceid);
268 spin_unlock(&tbl->slot_tbl_lock);
269 if (status)
270 goto out;
271 }
272 }
273
274out:
275 return status;
276}
277
Andy Adamson9733f0d2010-01-22 12:03:08 -0500278__be32 nfs4_callback_sequence(struct cb_sequenceargs *args,
Benny Halevyd49433e2009-04-01 09:23:25 -0400279 struct cb_sequenceres *res)
280{
Ricardo Labiaga68f3f902009-04-01 09:23:35 -0400281 struct nfs_client *clp;
Andy Adamson9733f0d2010-01-22 12:03:08 -0500282 int i;
283 __be32 status;
Benny Halevyd49433e2009-04-01 09:23:25 -0400284
Ricardo Labiaga68f3f902009-04-01 09:23:35 -0400285 status = htonl(NFS4ERR_BADSESSION);
286 clp = find_client_with_session(args->csa_addr, 4, &args->csa_sessionid);
287 if (clp == NULL)
288 goto out;
289
Andy Adamsonb2f28bd2010-01-14 17:45:07 -0500290 status = validate_seqid(&clp->cl_session->bc_slot_table, args);
Ricardo Labiaga68f3f902009-04-01 09:23:35 -0400291 if (status)
292 goto out_putclient;
293
Mike Sager72ce2b32010-01-19 12:54:41 -0500294 /*
295 * Check for pending referring calls. If a match is found, a
296 * related callback was received before the response to the original
297 * call.
298 */
299 if (referring_call_exists(clp, args->csa_nrclists, args->csa_rclists)) {
300 status = htonl(NFS4ERR_DELAY);
301 goto out_putclient;
302 }
303
Benny Halevyd49433e2009-04-01 09:23:25 -0400304 memcpy(&res->csr_sessionid, &args->csa_sessionid,
305 sizeof(res->csr_sessionid));
306 res->csr_sequenceid = args->csa_sequenceid;
307 res->csr_slotid = args->csa_slotid;
308 res->csr_highestslotid = NFS41_BC_MAX_CALLBACKS - 1;
309 res->csr_target_highestslotid = NFS41_BC_MAX_CALLBACKS - 1;
310
Ricardo Labiaga68f3f902009-04-01 09:23:35 -0400311out_putclient:
312 nfs_put_client(clp);
313out:
Mike Sager72ce2b32010-01-19 12:54:41 -0500314 for (i = 0; i < args->csa_nrclists; i++)
315 kfree(args->csa_rclists[i].rcl_refcalls);
316 kfree(args->csa_rclists);
317
Andy Adamson49110962010-01-14 17:45:08 -0500318 if (status == htonl(NFS4ERR_RETRY_UNCACHED_REP))
319 res->csr_status = 0;
320 else
321 res->csr_status = status;
322 dprintk("%s: exit with status = %d res->csr_status %d\n", __func__,
323 ntohl(status), ntohl(res->csr_status));
324 return status;
Benny Halevyd49433e2009-04-01 09:23:25 -0400325}
326
Andy Adamson9733f0d2010-01-22 12:03:08 -0500327__be32 nfs4_callback_recallany(struct cb_recallanyargs *args, void *dummy)
Alexandros Batsakis31f09602009-12-05 13:27:02 -0500328{
329 struct nfs_client *clp;
Andy Adamson9733f0d2010-01-22 12:03:08 -0500330 __be32 status;
Alexandros Batsakis31f09602009-12-05 13:27:02 -0500331 fmode_t flags = 0;
332
333 status = htonl(NFS4ERR_OP_NOT_IN_SESSION);
334 clp = nfs_find_client(args->craa_addr, 4);
335 if (clp == NULL)
336 goto out;
337
338 dprintk("NFS: RECALL_ANY callback request from %s\n",
339 rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_ADDR));
340
341 if (test_bit(RCA4_TYPE_MASK_RDATA_DLG, (const unsigned long *)
342 &args->craa_type_mask))
343 flags = FMODE_READ;
344 if (test_bit(RCA4_TYPE_MASK_WDATA_DLG, (const unsigned long *)
345 &args->craa_type_mask))
346 flags |= FMODE_WRITE;
347
348 if (flags)
349 nfs_expire_all_delegation_types(clp, flags);
350 status = htonl(NFS4_OK);
351out:
352 dprintk("%s: exit with status = %d\n", __func__, ntohl(status));
353 return status;
354}
Andy Adamsonb9efa1b2010-01-20 16:06:27 -0500355
356/* Reduce the fore channel's max_slots to the target value */
Andy Adamson9733f0d2010-01-22 12:03:08 -0500357__be32 nfs4_callback_recallslot(struct cb_recallslotargs *args, void *dummy)
Andy Adamsonb9efa1b2010-01-20 16:06:27 -0500358{
359 struct nfs_client *clp;
360 struct nfs4_slot_table *fc_tbl;
Andy Adamson9733f0d2010-01-22 12:03:08 -0500361 __be32 status;
Andy Adamsonb9efa1b2010-01-20 16:06:27 -0500362
363 status = htonl(NFS4ERR_OP_NOT_IN_SESSION);
364 clp = nfs_find_client(args->crsa_addr, 4);
365 if (clp == NULL)
366 goto out;
367
368 dprintk("NFS: CB_RECALL_SLOT request from %s target max slots %d\n",
369 rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_ADDR),
370 args->crsa_target_max_slots);
371
372 fc_tbl = &clp->cl_session->fc_slot_table;
373
374 status = htonl(NFS4ERR_BAD_HIGH_SLOT);
Andy Adamsonbae0ac02010-01-21 14:19:16 -0500375 if (args->crsa_target_max_slots > fc_tbl->max_slots ||
Andy Adamsonb9efa1b2010-01-20 16:06:27 -0500376 args->crsa_target_max_slots < 1)
Andy Adamsonbae0ac02010-01-21 14:19:16 -0500377 goto out_putclient;
378
379 status = htonl(NFS4_OK);
380 if (args->crsa_target_max_slots == fc_tbl->max_slots)
381 goto out_putclient;
Andy Adamsonb9efa1b2010-01-20 16:06:27 -0500382
383 fc_tbl->target_max_slots = args->crsa_target_max_slots;
384 nfs41_handle_recall_slot(clp);
Andy Adamsonbae0ac02010-01-21 14:19:16 -0500385out_putclient:
Andy Adamsonb9efa1b2010-01-20 16:06:27 -0500386 nfs_put_client(clp); /* balance nfs_find_client */
387out:
388 dprintk("%s: exit with status = %d\n", __func__, ntohl(status));
389 return status;
390}
Benny Halevyd49433e2009-04-01 09:23:25 -0400391#endif /* CONFIG_NFS_V4_1 */