NFSv4.1: use layout driver in global device cache
[linux-2.6.git] / fs / nfs / callback_proc.c
1 /*
2  * linux/fs/nfs/callback_proc.c
3  *
4  * Copyright (C) 2004 Trond Myklebust
5  *
6  * NFSv4 callback procedures
7  */
8 #include <linux/nfs4.h>
9 #include <linux/nfs_fs.h>
10 #include <linux/slab.h>
11 #include "nfs4_fs.h"
12 #include "callback.h"
13 #include "delegation.h"
14 #include "internal.h"
15 #include "pnfs.h"
16
17 #ifdef NFS_DEBUG
18 #define NFSDBG_FACILITY NFSDBG_CALLBACK
19 #endif
20
21 __be32 nfs4_callback_getattr(struct cb_getattrargs *args,
22                              struct cb_getattrres *res,
23                              struct cb_process_state *cps)
24 {
25         struct nfs_delegation *delegation;
26         struct nfs_inode *nfsi;
27         struct inode *inode;
28
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 */
31                 goto out;
32
33         res->bitmap[0] = res->bitmap[1] = 0;
34         res->status = htonl(NFS4ERR_BADHANDLE);
35
36         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);
40         if (inode == NULL)
41                 goto out;
42         nfsi = NFS_I(inode);
43         rcu_read_lock();
44         delegation = rcu_dereference(nfsi->delegation);
45         if (delegation == NULL || (delegation->type & FMODE_WRITE) == 0)
46                 goto out_iput;
47         res->size = i_size_read(inode);
48         res->change_attr = delegation->change_attr;
49         if (nfsi->npages != 0)
50                 res->change_attr++;
51         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;
58 out_iput:
59         rcu_read_unlock();
60         iput(inode);
61 out:
62         dprintk("%s: exit with status = %d\n", __func__, ntohl(res->status));
63         return res->status;
64 }
65
66 __be32 nfs4_callback_recall(struct cb_recallargs *args, void *dummy,
67                             struct cb_process_state *cps)
68 {
69         struct inode *inode;
70         __be32 res;
71         
72         res = htonl(NFS4ERR_OP_NOT_IN_SESSION);
73         if (!cps->clp) /* Always set for v4.0. Set in cb_sequence for v4.1 */
74                 goto out;
75
76         dprintk("NFS: RECALL callback request from %s\n",
77                 rpc_peeraddr2str(cps->clp->cl_rpcclient, RPC_DISPLAY_ADDR));
78
79         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);
96 out:
97         dprintk("%s: exit with status = %d\n", __func__, ntohl(res));
98         return res;
99 }
100
101 int 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
109 #if defined(CONFIG_NFS_V4_1)
110
111 static 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
154 static 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                 pnfs_free_lseg_list(&free_me_list);
192                 put_layout_hdr(lo);
193                 iput(ino);
194         }
195         return rv;
196 }
197
198 static 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);
211 out:
212         dprintk("%s returning %i\n", __func__, res);
213         return res;
214
215 }
216
217 __be32 nfs4_callback_layoutrecall(struct cb_layoutrecallargs *args,
218                                   void *dummy, struct cb_process_state *cps)
219 {
220         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);
231 }
232
233 static 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
244 __be32 nfs4_callback_devicenotify(struct cb_devicenotifyargs *args,
245                                   void *dummy, struct cb_process_state *cps)
246 {
247         int i;
248         __be32 res = 0;
249         struct nfs_client *clp = cps->clp;
250         struct nfs_server *server = NULL;
251
252         dprintk("%s: -->\n", __func__);
253
254         if (!clp) {
255                 res = cpu_to_be32(NFS4ERR_OP_NOT_IN_SESSION);
256                 goto out;
257         }
258
259         for (i = 0; i < args->ndevs; i++) {
260                 struct cb_devicenotifyitem *dev = &args->devs[i];
261
262                 if (!server ||
263                     server->pnfs_curr_ld->id != dev->cbd_layout_type) {
264                         rcu_read_lock();
265                         list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
266                                 if (server->pnfs_curr_ld &&
267                                     server->pnfs_curr_ld->id == dev->cbd_layout_type) {
268                                         rcu_read_unlock();
269                                         goto found;
270                                 }
271                         rcu_read_unlock();
272                         dprintk("%s: layout type %u not found\n",
273                                 __func__, dev->cbd_layout_type);
274                         continue;
275                 }
276
277         found:
278                 if (dev->cbd_notify_type == NOTIFY_DEVICEID4_CHANGE)
279                         dprintk("%s: NOTIFY_DEVICEID4_CHANGE not supported, "
280                                 "deleting instead\n", __func__);
281                 nfs4_delete_deviceid(server->pnfs_curr_ld, clp, &dev->cbd_dev_id);
282         }
283
284 out:
285         kfree(args->devs);
286         dprintk("%s: exit with status = %u\n",
287                 __func__, be32_to_cpu(res));
288         return res;
289 }
290
291 int nfs41_validate_delegation_stateid(struct nfs_delegation *delegation, const nfs4_stateid *stateid)
292 {
293         if (delegation == NULL)
294                 return 0;
295
296         if (stateid->stateid.seqid != 0)
297                 return 0;
298         if (memcmp(&delegation->stateid.stateid.other,
299                    &stateid->stateid.other,
300                    NFS4_STATEID_OTHER_SIZE))
301                 return 0;
302
303         return 1;
304 }
305
306 /*
307  * Validate the sequenceID sent by the server.
308  * Return success if the sequenceID is one more than what we last saw on
309  * this slot, accounting for wraparound.  Increments the slot's sequence.
310  *
311  * We don't yet implement a duplicate request cache, instead we set the
312  * back channel ca_maxresponsesize_cached to zero. This is OK for now
313  * since we only currently implement idempotent callbacks anyway.
314  *
315  * We have a single slot backchannel at this time, so we don't bother
316  * checking the used_slots bit array on the table.  The lower layer guarantees
317  * a single outstanding callback request at a time.
318  */
319 static __be32
320 validate_seqid(struct nfs4_slot_table *tbl, struct cb_sequenceargs * args)
321 {
322         struct nfs4_slot *slot;
323
324         dprintk("%s enter. slotid %d seqid %d\n",
325                 __func__, args->csa_slotid, args->csa_sequenceid);
326
327         if (args->csa_slotid > NFS41_BC_MAX_CALLBACKS)
328                 return htonl(NFS4ERR_BADSLOT);
329
330         slot = tbl->slots + args->csa_slotid;
331         dprintk("%s slot table seqid: %d\n", __func__, slot->seq_nr);
332
333         /* Normal */
334         if (likely(args->csa_sequenceid == slot->seq_nr + 1)) {
335                 slot->seq_nr++;
336                 return htonl(NFS4_OK);
337         }
338
339         /* Replay */
340         if (args->csa_sequenceid == slot->seq_nr) {
341                 dprintk("%s seqid %d is a replay\n",
342                         __func__, args->csa_sequenceid);
343                 /* Signal process_op to set this error on next op */
344                 if (args->csa_cachethis == 0)
345                         return htonl(NFS4ERR_RETRY_UNCACHED_REP);
346
347                 /* The ca_maxresponsesize_cached is 0 with no DRC */
348                 else if (args->csa_cachethis == 1)
349                         return htonl(NFS4ERR_REP_TOO_BIG_TO_CACHE);
350         }
351
352         /* Wraparound */
353         if (args->csa_sequenceid == 1 && (slot->seq_nr + 1) == 0) {
354                 slot->seq_nr = 1;
355                 return htonl(NFS4_OK);
356         }
357
358         /* Misordered request */
359         return htonl(NFS4ERR_SEQ_MISORDERED);
360 }
361
362 /*
363  * For each referring call triple, check the session's slot table for
364  * a match.  If the slot is in use and the sequence numbers match, the
365  * client is still waiting for a response to the original request.
366  */
367 static bool referring_call_exists(struct nfs_client *clp,
368                                   uint32_t nrclists,
369                                   struct referring_call_list *rclists)
370 {
371         bool status = 0;
372         int i, j;
373         struct nfs4_session *session;
374         struct nfs4_slot_table *tbl;
375         struct referring_call_list *rclist;
376         struct referring_call *ref;
377
378         /*
379          * XXX When client trunking is implemented, this becomes
380          * a session lookup from within the loop
381          */
382         session = clp->cl_session;
383         tbl = &session->fc_slot_table;
384
385         for (i = 0; i < nrclists; i++) {
386                 rclist = &rclists[i];
387                 if (memcmp(session->sess_id.data,
388                            rclist->rcl_sessionid.data,
389                            NFS4_MAX_SESSIONID_LEN) != 0)
390                         continue;
391
392                 for (j = 0; j < rclist->rcl_nrefcalls; j++) {
393                         ref = &rclist->rcl_refcalls[j];
394
395                         dprintk("%s: sessionid %x:%x:%x:%x sequenceid %u "
396                                 "slotid %u\n", __func__,
397                                 ((u32 *)&rclist->rcl_sessionid.data)[0],
398                                 ((u32 *)&rclist->rcl_sessionid.data)[1],
399                                 ((u32 *)&rclist->rcl_sessionid.data)[2],
400                                 ((u32 *)&rclist->rcl_sessionid.data)[3],
401                                 ref->rc_sequenceid, ref->rc_slotid);
402
403                         spin_lock(&tbl->slot_tbl_lock);
404                         status = (test_bit(ref->rc_slotid, tbl->used_slots) &&
405                                   tbl->slots[ref->rc_slotid].seq_nr ==
406                                         ref->rc_sequenceid);
407                         spin_unlock(&tbl->slot_tbl_lock);
408                         if (status)
409                                 goto out;
410                 }
411         }
412
413 out:
414         return status;
415 }
416
417 __be32 nfs4_callback_sequence(struct cb_sequenceargs *args,
418                               struct cb_sequenceres *res,
419                               struct cb_process_state *cps)
420 {
421         struct nfs_client *clp;
422         int i;
423         __be32 status = htonl(NFS4ERR_BADSESSION);
424
425         cps->clp = NULL;
426
427         clp = nfs4_find_client_sessionid(args->csa_addr, &args->csa_sessionid);
428         if (clp == NULL)
429                 goto out;
430
431         /* state manager is resetting the session */
432         if (test_bit(NFS4_SESSION_DRAINING, &clp->cl_session->session_state)) {
433                 status = NFS4ERR_DELAY;
434                 goto out;
435         }
436
437         status = validate_seqid(&clp->cl_session->bc_slot_table, args);
438         if (status)
439                 goto out;
440
441         /*
442          * Check for pending referring calls.  If a match is found, a
443          * related callback was received before the response to the original
444          * call.
445          */
446         if (referring_call_exists(clp, args->csa_nrclists, args->csa_rclists)) {
447                 status = htonl(NFS4ERR_DELAY);
448                 goto out;
449         }
450
451         memcpy(&res->csr_sessionid, &args->csa_sessionid,
452                sizeof(res->csr_sessionid));
453         res->csr_sequenceid = args->csa_sequenceid;
454         res->csr_slotid = args->csa_slotid;
455         res->csr_highestslotid = NFS41_BC_MAX_CALLBACKS - 1;
456         res->csr_target_highestslotid = NFS41_BC_MAX_CALLBACKS - 1;
457         nfs4_cb_take_slot(clp);
458
459 out:
460         cps->clp = clp; /* put in nfs4_callback_compound */
461         for (i = 0; i < args->csa_nrclists; i++)
462                 kfree(args->csa_rclists[i].rcl_refcalls);
463         kfree(args->csa_rclists);
464
465         if (status == htonl(NFS4ERR_RETRY_UNCACHED_REP)) {
466                 cps->drc_status = status;
467                 status = 0;
468         } else
469                 res->csr_status = status;
470
471         dprintk("%s: exit with status = %d res->csr_status %d\n", __func__,
472                 ntohl(status), ntohl(res->csr_status));
473         return status;
474 }
475
476 static bool
477 validate_bitmap_values(unsigned long mask)
478 {
479         return (mask & ~RCA4_TYPE_MASK_ALL) == 0;
480 }
481
482 __be32 nfs4_callback_recallany(struct cb_recallanyargs *args, void *dummy,
483                                struct cb_process_state *cps)
484 {
485         __be32 status;
486         fmode_t flags = 0;
487
488         status = cpu_to_be32(NFS4ERR_OP_NOT_IN_SESSION);
489         if (!cps->clp) /* set in cb_sequence */
490                 goto out;
491
492         dprintk("NFS: RECALL_ANY callback request from %s\n",
493                 rpc_peeraddr2str(cps->clp->cl_rpcclient, RPC_DISPLAY_ADDR));
494
495         status = cpu_to_be32(NFS4ERR_INVAL);
496         if (!validate_bitmap_values(args->craa_type_mask))
497                 goto out;
498
499         status = cpu_to_be32(NFS4_OK);
500         if (test_bit(RCA4_TYPE_MASK_RDATA_DLG, (const unsigned long *)
501                      &args->craa_type_mask))
502                 flags = FMODE_READ;
503         if (test_bit(RCA4_TYPE_MASK_WDATA_DLG, (const unsigned long *)
504                      &args->craa_type_mask))
505                 flags |= FMODE_WRITE;
506         if (test_bit(RCA4_TYPE_MASK_FILE_LAYOUT, (const unsigned long *)
507                      &args->craa_type_mask))
508                 pnfs_recall_all_layouts(cps->clp);
509         if (flags)
510                 nfs_expire_all_delegation_types(cps->clp, flags);
511 out:
512         dprintk("%s: exit with status = %d\n", __func__, ntohl(status));
513         return status;
514 }
515
516 /* Reduce the fore channel's max_slots to the target value */
517 __be32 nfs4_callback_recallslot(struct cb_recallslotargs *args, void *dummy,
518                                 struct cb_process_state *cps)
519 {
520         struct nfs4_slot_table *fc_tbl;
521         __be32 status;
522
523         status = htonl(NFS4ERR_OP_NOT_IN_SESSION);
524         if (!cps->clp) /* set in cb_sequence */
525                 goto out;
526
527         dprintk("NFS: CB_RECALL_SLOT request from %s target max slots %d\n",
528                 rpc_peeraddr2str(cps->clp->cl_rpcclient, RPC_DISPLAY_ADDR),
529                 args->crsa_target_max_slots);
530
531         fc_tbl = &cps->clp->cl_session->fc_slot_table;
532
533         status = htonl(NFS4ERR_BAD_HIGH_SLOT);
534         if (args->crsa_target_max_slots > fc_tbl->max_slots ||
535             args->crsa_target_max_slots < 1)
536                 goto out;
537
538         status = htonl(NFS4_OK);
539         if (args->crsa_target_max_slots == fc_tbl->max_slots)
540                 goto out;
541
542         fc_tbl->target_max_slots = args->crsa_target_max_slots;
543         nfs41_handle_recall_slot(cps->clp);
544 out:
545         dprintk("%s: exit with status = %d\n", __func__, ntohl(status));
546         return status;
547 }
548 #endif /* CONFIG_NFS_V4_1 */