~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/nfs/pnfs.c

Version: ~ [ linux-5.1-rc5 ] ~ [ linux-5.0.7 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.34 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.111 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.168 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.178 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.138 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.65 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  *  pNFS functions to call and manage layout drivers.
  3  *
  4  *  Copyright (c) 2002 [year of first publication]
  5  *  The Regents of the University of Michigan
  6  *  All Rights Reserved
  7  *
  8  *  Dean Hildebrand <dhildebz@umich.edu>
  9  *
 10  *  Permission is granted to use, copy, create derivative works, and
 11  *  redistribute this software and such derivative works for any purpose,
 12  *  so long as the name of the University of Michigan is not used in
 13  *  any advertising or publicity pertaining to the use or distribution
 14  *  of this software without specific, written prior authorization. If
 15  *  the above copyright notice or any other identification of the
 16  *  University of Michigan is included in any copy of any portion of
 17  *  this software, then the disclaimer below must also be included.
 18  *
 19  *  This software is provided as is, without representation or warranty
 20  *  of any kind either express or implied, including without limitation
 21  *  the implied warranties of merchantability, fitness for a particular
 22  *  purpose, or noninfringement.  The Regents of the University of
 23  *  Michigan shall not be liable for any damages, including special,
 24  *  indirect, incidental, or consequential damages, with respect to any
 25  *  claim arising out of or in connection with the use of the software,
 26  *  even if it has been or is hereafter advised of the possibility of
 27  *  such damages.
 28  */
 29 
 30 #include <linux/nfs_fs.h>
 31 #include "internal.h"
 32 #include "pnfs.h"
 33 #include "iostat.h"
 34 
 35 #define NFSDBG_FACILITY         NFSDBG_PNFS
 36 
 37 /* Locking:
 38  *
 39  * pnfs_spinlock:
 40  *      protects pnfs_modules_tbl.
 41  */
 42 static DEFINE_SPINLOCK(pnfs_spinlock);
 43 
 44 /*
 45  * pnfs_modules_tbl holds all pnfs modules
 46  */
 47 static LIST_HEAD(pnfs_modules_tbl);
 48 
 49 /* Return the registered pnfs layout driver module matching given id */
 50 static struct pnfs_layoutdriver_type *
 51 find_pnfs_driver_locked(u32 id)
 52 {
 53         struct pnfs_layoutdriver_type *local;
 54 
 55         list_for_each_entry(local, &pnfs_modules_tbl, pnfs_tblid)
 56                 if (local->id == id)
 57                         goto out;
 58         local = NULL;
 59 out:
 60         dprintk("%s: Searching for id %u, found %p\n", __func__, id, local);
 61         return local;
 62 }
 63 
 64 static struct pnfs_layoutdriver_type *
 65 find_pnfs_driver(u32 id)
 66 {
 67         struct pnfs_layoutdriver_type *local;
 68 
 69         spin_lock(&pnfs_spinlock);
 70         local = find_pnfs_driver_locked(id);
 71         spin_unlock(&pnfs_spinlock);
 72         return local;
 73 }
 74 
 75 void
 76 unset_pnfs_layoutdriver(struct nfs_server *nfss)
 77 {
 78         if (nfss->pnfs_curr_ld)
 79                 module_put(nfss->pnfs_curr_ld->owner);
 80         nfss->pnfs_curr_ld = NULL;
 81 }
 82 
 83 /*
 84  * Try to set the server's pnfs module to the pnfs layout type specified by id.
 85  * Currently only one pNFS layout driver per filesystem is supported.
 86  *
 87  * @id layout type. Zero (illegal layout type) indicates pNFS not in use.
 88  */
 89 void
 90 set_pnfs_layoutdriver(struct nfs_server *server, u32 id)
 91 {
 92         struct pnfs_layoutdriver_type *ld_type = NULL;
 93 
 94         if (id == 0)
 95                 goto out_no_driver;
 96         if (!(server->nfs_client->cl_exchange_flags &
 97                  (EXCHGID4_FLAG_USE_NON_PNFS | EXCHGID4_FLAG_USE_PNFS_MDS))) {
 98                 printk(KERN_ERR "%s: id %u cl_exchange_flags 0x%x\n", __func__,
 99                        id, server->nfs_client->cl_exchange_flags);
100                 goto out_no_driver;
101         }
102         ld_type = find_pnfs_driver(id);
103         if (!ld_type) {
104                 request_module("%s-%u", LAYOUT_NFSV4_1_MODULE_PREFIX, id);
105                 ld_type = find_pnfs_driver(id);
106                 if (!ld_type) {
107                         dprintk("%s: No pNFS module found for %u.\n",
108                                 __func__, id);
109                         goto out_no_driver;
110                 }
111         }
112         if (!try_module_get(ld_type->owner)) {
113                 dprintk("%s: Could not grab reference on module\n", __func__);
114                 goto out_no_driver;
115         }
116         server->pnfs_curr_ld = ld_type;
117 
118         dprintk("%s: pNFS module for %u set\n", __func__, id);
119         return;
120 
121 out_no_driver:
122         dprintk("%s: Using NFSv4 I/O\n", __func__);
123         server->pnfs_curr_ld = NULL;
124 }
125 
126 int
127 pnfs_register_layoutdriver(struct pnfs_layoutdriver_type *ld_type)
128 {
129         int status = -EINVAL;
130         struct pnfs_layoutdriver_type *tmp;
131 
132         if (ld_type->id == 0) {
133                 printk(KERN_ERR "%s id 0 is reserved\n", __func__);
134                 return status;
135         }
136         if (!ld_type->alloc_lseg || !ld_type->free_lseg) {
137                 printk(KERN_ERR "%s Layout driver must provide "
138                        "alloc_lseg and free_lseg.\n", __func__);
139                 return status;
140         }
141 
142         spin_lock(&pnfs_spinlock);
143         tmp = find_pnfs_driver_locked(ld_type->id);
144         if (!tmp) {
145                 list_add(&ld_type->pnfs_tblid, &pnfs_modules_tbl);
146                 status = 0;
147                 dprintk("%s Registering id:%u name:%s\n", __func__, ld_type->id,
148                         ld_type->name);
149         } else {
150                 printk(KERN_ERR "%s Module with id %d already loaded!\n",
151                         __func__, ld_type->id);
152         }
153         spin_unlock(&pnfs_spinlock);
154 
155         return status;
156 }
157 EXPORT_SYMBOL_GPL(pnfs_register_layoutdriver);
158 
159 void
160 pnfs_unregister_layoutdriver(struct pnfs_layoutdriver_type *ld_type)
161 {
162         dprintk("%s Deregistering id:%u\n", __func__, ld_type->id);
163         spin_lock(&pnfs_spinlock);
164         list_del(&ld_type->pnfs_tblid);
165         spin_unlock(&pnfs_spinlock);
166 }
167 EXPORT_SYMBOL_GPL(pnfs_unregister_layoutdriver);
168 
169 /*
170  * pNFS client layout cache
171  */
172 
173 /* Need to hold i_lock if caller does not already hold reference */
174 void
175 get_layout_hdr(struct pnfs_layout_hdr *lo)
176 {
177         atomic_inc(&lo->plh_refcount);
178 }
179 
180 static struct pnfs_layout_hdr *
181 pnfs_alloc_layout_hdr(struct inode *ino, gfp_t gfp_flags)
182 {
183         struct pnfs_layoutdriver_type *ld = NFS_SERVER(ino)->pnfs_curr_ld;
184         return ld->alloc_layout_hdr ? ld->alloc_layout_hdr(ino, gfp_flags) :
185                 kzalloc(sizeof(struct pnfs_layout_hdr), gfp_flags);
186 }
187 
188 static void
189 pnfs_free_layout_hdr(struct pnfs_layout_hdr *lo)
190 {
191         struct pnfs_layoutdriver_type *ld = NFS_SERVER(lo->plh_inode)->pnfs_curr_ld;
192         put_rpccred(lo->plh_lc_cred);
193         return ld->alloc_layout_hdr ? ld->free_layout_hdr(lo) : kfree(lo);
194 }
195 
196 static void
197 destroy_layout_hdr(struct pnfs_layout_hdr *lo)
198 {
199         dprintk("%s: freeing layout cache %p\n", __func__, lo);
200         BUG_ON(!list_empty(&lo->plh_layouts));
201         NFS_I(lo->plh_inode)->layout = NULL;
202         pnfs_free_layout_hdr(lo);
203 }
204 
205 static void
206 put_layout_hdr_locked(struct pnfs_layout_hdr *lo)
207 {
208         if (atomic_dec_and_test(&lo->plh_refcount))
209                 destroy_layout_hdr(lo);
210 }
211 
212 void
213 put_layout_hdr(struct pnfs_layout_hdr *lo)
214 {
215         struct inode *inode = lo->plh_inode;
216 
217         if (atomic_dec_and_lock(&lo->plh_refcount, &inode->i_lock)) {
218                 destroy_layout_hdr(lo);
219                 spin_unlock(&inode->i_lock);
220         }
221 }
222 
223 static void
224 init_lseg(struct pnfs_layout_hdr *lo, struct pnfs_layout_segment *lseg)
225 {
226         INIT_LIST_HEAD(&lseg->pls_list);
227         INIT_LIST_HEAD(&lseg->pls_lc_list);
228         atomic_set(&lseg->pls_refcount, 1);
229         smp_mb();
230         set_bit(NFS_LSEG_VALID, &lseg->pls_flags);
231         lseg->pls_layout = lo;
232 }
233 
234 static void free_lseg(struct pnfs_layout_segment *lseg)
235 {
236         struct inode *ino = lseg->pls_layout->plh_inode;
237 
238         NFS_SERVER(ino)->pnfs_curr_ld->free_lseg(lseg);
239         /* Matched by get_layout_hdr in pnfs_insert_layout */
240         put_layout_hdr(NFS_I(ino)->layout);
241 }
242 
243 static void
244 put_lseg_common(struct pnfs_layout_segment *lseg)
245 {
246         struct inode *inode = lseg->pls_layout->plh_inode;
247 
248         WARN_ON(test_bit(NFS_LSEG_VALID, &lseg->pls_flags));
249         list_del_init(&lseg->pls_list);
250         if (list_empty(&lseg->pls_layout->plh_segs)) {
251                 set_bit(NFS_LAYOUT_DESTROYED, &lseg->pls_layout->plh_flags);
252                 /* Matched by initial refcount set in alloc_init_layout_hdr */
253                 put_layout_hdr_locked(lseg->pls_layout);
254         }
255         rpc_wake_up(&NFS_SERVER(inode)->roc_rpcwaitq);
256 }
257 
258 void
259 put_lseg(struct pnfs_layout_segment *lseg)
260 {
261         struct inode *inode;
262 
263         if (!lseg)
264                 return;
265 
266         dprintk("%s: lseg %p ref %d valid %d\n", __func__, lseg,
267                 atomic_read(&lseg->pls_refcount),
268                 test_bit(NFS_LSEG_VALID, &lseg->pls_flags));
269         inode = lseg->pls_layout->plh_inode;
270         if (atomic_dec_and_lock(&lseg->pls_refcount, &inode->i_lock)) {
271                 LIST_HEAD(free_me);
272 
273                 put_lseg_common(lseg);
274                 list_add(&lseg->pls_list, &free_me);
275                 spin_unlock(&inode->i_lock);
276                 pnfs_free_lseg_list(&free_me);
277         }
278 }
279 EXPORT_SYMBOL_GPL(put_lseg);
280 
281 static inline u64
282 end_offset(u64 start, u64 len)
283 {
284         u64 end;
285 
286         end = start + len;
287         return end >= start ? end : NFS4_MAX_UINT64;
288 }
289 
290 /* last octet in a range */
291 static inline u64
292 last_byte_offset(u64 start, u64 len)
293 {
294         u64 end;
295 
296         BUG_ON(!len);
297         end = start + len;
298         return end > start ? end - 1 : NFS4_MAX_UINT64;
299 }
300 
301 /*
302  * is l2 fully contained in l1?
303  *   start1                             end1
304  *   [----------------------------------)
305  *           start2           end2
306  *           [----------------)
307  */
308 static inline int
309 lo_seg_contained(struct pnfs_layout_range *l1,
310                  struct pnfs_layout_range *l2)
311 {
312         u64 start1 = l1->offset;
313         u64 end1 = end_offset(start1, l1->length);
314         u64 start2 = l2->offset;
315         u64 end2 = end_offset(start2, l2->length);
316 
317         return (start1 <= start2) && (end1 >= end2);
318 }
319 
320 /*
321  * is l1 and l2 intersecting?
322  *   start1                             end1
323  *   [----------------------------------)
324  *                              start2           end2
325  *                              [----------------)
326  */
327 static inline int
328 lo_seg_intersecting(struct pnfs_layout_range *l1,
329                     struct pnfs_layout_range *l2)
330 {
331         u64 start1 = l1->offset;
332         u64 end1 = end_offset(start1, l1->length);
333         u64 start2 = l2->offset;
334         u64 end2 = end_offset(start2, l2->length);
335 
336         return (end1 == NFS4_MAX_UINT64 || end1 > start2) &&
337                (end2 == NFS4_MAX_UINT64 || end2 > start1);
338 }
339 
340 static bool
341 should_free_lseg(struct pnfs_layout_range *lseg_range,
342                  struct pnfs_layout_range *recall_range)
343 {
344         return (recall_range->iomode == IOMODE_ANY ||
345                 lseg_range->iomode == recall_range->iomode) &&
346                lo_seg_intersecting(lseg_range, recall_range);
347 }
348 
349 /* Returns 1 if lseg is removed from list, 0 otherwise */
350 static int mark_lseg_invalid(struct pnfs_layout_segment *lseg,
351                              struct list_head *tmp_list)
352 {
353         int rv = 0;
354 
355         if (test_and_clear_bit(NFS_LSEG_VALID, &lseg->pls_flags)) {
356                 /* Remove the reference keeping the lseg in the
357                  * list.  It will now be removed when all
358                  * outstanding io is finished.
359                  */
360                 dprintk("%s: lseg %p ref %d\n", __func__, lseg,
361                         atomic_read(&lseg->pls_refcount));
362                 if (atomic_dec_and_test(&lseg->pls_refcount)) {
363                         put_lseg_common(lseg);
364                         list_add(&lseg->pls_list, tmp_list);
365                         rv = 1;
366                 }
367         }
368         return rv;
369 }
370 
371 /* Returns count of number of matching invalid lsegs remaining in list
372  * after call.
373  */
374 int
375 mark_matching_lsegs_invalid(struct pnfs_layout_hdr *lo,
376                             struct list_head *tmp_list,
377                             struct pnfs_layout_range *recall_range)
378 {
379         struct pnfs_layout_segment *lseg, *next;
380         int invalid = 0, removed = 0;
381 
382         dprintk("%s:Begin lo %p\n", __func__, lo);
383 
384         if (list_empty(&lo->plh_segs)) {
385                 if (!test_and_set_bit(NFS_LAYOUT_DESTROYED, &lo->plh_flags))
386                         put_layout_hdr_locked(lo);
387                 return 0;
388         }
389         list_for_each_entry_safe(lseg, next, &lo->plh_segs, pls_list)
390                 if (!recall_range ||
391                     should_free_lseg(&lseg->pls_range, recall_range)) {
392                         dprintk("%s: freeing lseg %p iomode %d "
393                                 "offset %llu length %llu\n", __func__,
394                                 lseg, lseg->pls_range.iomode, lseg->pls_range.offset,
395                                 lseg->pls_range.length);
396                         invalid++;
397                         removed += mark_lseg_invalid(lseg, tmp_list);
398                 }
399         dprintk("%s:Return %i\n", __func__, invalid - removed);
400         return invalid - removed;
401 }
402 
403 /* note free_me must contain lsegs from a single layout_hdr */
404 void
405 pnfs_free_lseg_list(struct list_head *free_me)
406 {
407         struct pnfs_layout_segment *lseg, *tmp;
408         struct pnfs_layout_hdr *lo;
409 
410         if (list_empty(free_me))
411                 return;
412 
413         lo = list_first_entry(free_me, struct pnfs_layout_segment,
414                               pls_list)->pls_layout;
415 
416         if (test_bit(NFS_LAYOUT_DESTROYED, &lo->plh_flags)) {
417                 struct nfs_client *clp;
418 
419                 clp = NFS_SERVER(lo->plh_inode)->nfs_client;
420                 spin_lock(&clp->cl_lock);
421                 list_del_init(&lo->plh_layouts);
422                 spin_unlock(&clp->cl_lock);
423         }
424         list_for_each_entry_safe(lseg, tmp, free_me, pls_list) {
425                 list_del(&lseg->pls_list);
426                 free_lseg(lseg);
427         }
428 }
429 
430 void
431 pnfs_destroy_layout(struct nfs_inode *nfsi)
432 {
433         struct pnfs_layout_hdr *lo;
434         LIST_HEAD(tmp_list);
435 
436         spin_lock(&nfsi->vfs_inode.i_lock);
437         lo = nfsi->layout;
438         if (lo) {
439                 lo->plh_block_lgets++; /* permanently block new LAYOUTGETs */
440                 mark_matching_lsegs_invalid(lo, &tmp_list, NULL);
441         }
442         spin_unlock(&nfsi->vfs_inode.i_lock);
443         pnfs_free_lseg_list(&tmp_list);
444 }
445 
446 /*
447  * Called by the state manger to remove all layouts established under an
448  * expired lease.
449  */
450 void
451 pnfs_destroy_all_layouts(struct nfs_client *clp)
452 {
453         struct pnfs_layout_hdr *lo;
454         LIST_HEAD(tmp_list);
455 
456         spin_lock(&clp->cl_lock);
457         list_splice_init(&clp->cl_layouts, &tmp_list);
458         spin_unlock(&clp->cl_lock);
459 
460         while (!list_empty(&tmp_list)) {
461                 lo = list_entry(tmp_list.next, struct pnfs_layout_hdr,
462                                 plh_layouts);
463                 dprintk("%s freeing layout for inode %lu\n", __func__,
464                         lo->plh_inode->i_ino);
465                 list_del_init(&lo->plh_layouts);
466                 pnfs_destroy_layout(NFS_I(lo->plh_inode));
467         }
468 }
469 
470 /* update lo->plh_stateid with new if is more recent */
471 void
472 pnfs_set_layout_stateid(struct pnfs_layout_hdr *lo, const nfs4_stateid *new,
473                         bool update_barrier)
474 {
475         u32 oldseq, newseq;
476 
477         oldseq = be32_to_cpu(lo->plh_stateid.stateid.seqid);
478         newseq = be32_to_cpu(new->stateid.seqid);
479         if ((int)(newseq - oldseq) > 0) {
480                 memcpy(&lo->plh_stateid, &new->stateid, sizeof(new->stateid));
481                 if (update_barrier) {
482                         u32 new_barrier = be32_to_cpu(new->stateid.seqid);
483 
484                         if ((int)(new_barrier - lo->plh_barrier))
485                                 lo->plh_barrier = new_barrier;
486                 } else {
487                         /* Because of wraparound, we want to keep the barrier
488                          * "close" to the current seqids.  It needs to be
489                          * within 2**31 to count as "behind", so if it
490                          * gets too near that limit, give us a litle leeway
491                          * and bring it to within 2**30.
492                          * NOTE - and yes, this is all unsigned arithmetic.
493                          */
494                         if (unlikely((newseq - lo->plh_barrier) > (3 << 29)))
495                                 lo->plh_barrier = newseq - (1 << 30);
496                 }
497         }
498 }
499 
500 /* lget is set to 1 if called from inside send_layoutget call chain */
501 static bool
502 pnfs_layoutgets_blocked(struct pnfs_layout_hdr *lo, nfs4_stateid *stateid,
503                         int lget)
504 {
505         if ((stateid) &&
506             (int)(lo->plh_barrier - be32_to_cpu(stateid->stateid.seqid)) >= 0)
507                 return true;
508         return lo->plh_block_lgets ||
509                 test_bit(NFS_LAYOUT_DESTROYED, &lo->plh_flags) ||
510                 test_bit(NFS_LAYOUT_BULK_RECALL, &lo->plh_flags) ||
511                 (list_empty(&lo->plh_segs) &&
512                  (atomic_read(&lo->plh_outstanding) > lget));
513 }
514 
515 int
516 pnfs_choose_layoutget_stateid(nfs4_stateid *dst, struct pnfs_layout_hdr *lo,
517                               struct nfs4_state *open_state)
518 {
519         int status = 0;
520 
521         dprintk("--> %s\n", __func__);
522         spin_lock(&lo->plh_inode->i_lock);
523         if (pnfs_layoutgets_blocked(lo, NULL, 1)) {
524                 status = -EAGAIN;
525         } else if (list_empty(&lo->plh_segs)) {
526                 int seq;
527 
528                 do {
529                         seq = read_seqbegin(&open_state->seqlock);
530                         memcpy(dst->data, open_state->stateid.data,
531                                sizeof(open_state->stateid.data));
532                 } while (read_seqretry(&open_state->seqlock, seq));
533         } else
534                 memcpy(dst->data, lo->plh_stateid.data, sizeof(lo->plh_stateid.data));
535         spin_unlock(&lo->plh_inode->i_lock);
536         dprintk("<-- %s\n", __func__);
537         return status;
538 }
539 
540 /*
541 * Get layout from server.
542 *    for now, assume that whole file layouts are requested.
543 *    arg->offset: 0
544 *    arg->length: all ones
545 */
546 static struct pnfs_layout_segment *
547 send_layoutget(struct pnfs_layout_hdr *lo,
548            struct nfs_open_context *ctx,
549            struct pnfs_layout_range *range,
550            gfp_t gfp_flags)
551 {
552         struct inode *ino = lo->plh_inode;
553         struct nfs_server *server = NFS_SERVER(ino);
554         struct nfs4_layoutget *lgp;
555         struct pnfs_layout_segment *lseg = NULL;
556         struct page **pages = NULL;
557         int i;
558         u32 max_resp_sz, max_pages;
559 
560         dprintk("--> %s\n", __func__);
561 
562         BUG_ON(ctx == NULL);
563         lgp = kzalloc(sizeof(*lgp), gfp_flags);
564         if (lgp == NULL)
565                 return NULL;
566 
567         /* allocate pages for xdr post processing */
568         max_resp_sz = server->nfs_client->cl_session->fc_attrs.max_resp_sz;
569         max_pages = max_resp_sz >> PAGE_SHIFT;
570 
571         pages = kzalloc(max_pages * sizeof(struct page *), gfp_flags);
572         if (!pages)
573                 goto out_err_free;
574 
575         for (i = 0; i < max_pages; i++) {
576                 pages[i] = alloc_page(gfp_flags);
577                 if (!pages[i])
578                         goto out_err_free;
579         }
580 
581         lgp->args.minlength = PAGE_CACHE_SIZE;
582         if (lgp->args.minlength > range->length)
583                 lgp->args.minlength = range->length;
584         lgp->args.maxcount = PNFS_LAYOUT_MAXSIZE;
585         lgp->args.range = *range;
586         lgp->args.type = server->pnfs_curr_ld->id;
587         lgp->args.inode = ino;
588         lgp->args.ctx = get_nfs_open_context(ctx);
589         lgp->args.layout.pages = pages;
590         lgp->args.layout.pglen = max_pages * PAGE_SIZE;
591         lgp->lsegpp = &lseg;
592         lgp->gfp_flags = gfp_flags;
593 
594         /* Synchronously retrieve layout information from server and
595          * store in lseg.
596          */
597         nfs4_proc_layoutget(lgp);
598         if (!lseg) {
599                 /* remember that LAYOUTGET failed and suspend trying */
600                 set_bit(lo_fail_bit(range->iomode), &lo->plh_flags);
601         }
602 
603         /* free xdr pages */
604         for (i = 0; i < max_pages; i++)
605                 __free_page(pages[i]);
606         kfree(pages);
607 
608         return lseg;
609 
610 out_err_free:
611         /* free any allocated xdr pages, lgp as it's not used */
612         if (pages) {
613                 for (i = 0; i < max_pages; i++) {
614                         if (!pages[i])
615                                 break;
616                         __free_page(pages[i]);
617                 }
618                 kfree(pages);
619         }
620         kfree(lgp);
621         return NULL;
622 }
623 
624 /* Initiates a LAYOUTRETURN(FILE) */
625 int
626 _pnfs_return_layout(struct inode *ino)
627 {
628         struct pnfs_layout_hdr *lo = NULL;
629         struct nfs_inode *nfsi = NFS_I(ino);
630         LIST_HEAD(tmp_list);
631         struct nfs4_layoutreturn *lrp;
632         nfs4_stateid stateid;
633         int status = 0;
634 
635         dprintk("--> %s\n", __func__);
636 
637         spin_lock(&ino->i_lock);
638         lo = nfsi->layout;
639         if (!lo) {
640                 spin_unlock(&ino->i_lock);
641                 dprintk("%s: no layout to return\n", __func__);
642                 return status;
643         }
644         stateid = nfsi->layout->plh_stateid;
645         /* Reference matched in nfs4_layoutreturn_release */
646         get_layout_hdr(lo);
647         mark_matching_lsegs_invalid(lo, &tmp_list, NULL);
648         lo->plh_block_lgets++;
649         spin_unlock(&ino->i_lock);
650         pnfs_free_lseg_list(&tmp_list);
651 
652         WARN_ON(test_bit(NFS_INO_LAYOUTCOMMIT, &nfsi->flags));
653 
654         lrp = kzalloc(sizeof(*lrp), GFP_KERNEL);
655         if (unlikely(lrp == NULL)) {
656                 status = -ENOMEM;
657                 set_bit(NFS_LAYOUT_RW_FAILED, &lo->plh_flags);
658                 set_bit(NFS_LAYOUT_RO_FAILED, &lo->plh_flags);
659                 put_layout_hdr(lo);
660                 goto out;
661         }
662 
663         lrp->args.stateid = stateid;
664         lrp->args.layout_type = NFS_SERVER(ino)->pnfs_curr_ld->id;
665         lrp->args.inode = ino;
666         lrp->clp = NFS_SERVER(ino)->nfs_client;
667 
668         status = nfs4_proc_layoutreturn(lrp);
669 out:
670         dprintk("<-- %s status: %d\n", __func__, status);
671         return status;
672 }
673 
674 bool pnfs_roc(struct inode *ino)
675 {
676         struct pnfs_layout_hdr *lo;
677         struct pnfs_layout_segment *lseg, *tmp;
678         LIST_HEAD(tmp_list);
679         bool found = false;
680 
681         spin_lock(&ino->i_lock);
682         lo = NFS_I(ino)->layout;
683         if (!lo || !test_and_clear_bit(NFS_LAYOUT_ROC, &lo->plh_flags) ||
684             test_bit(NFS_LAYOUT_BULK_RECALL, &lo->plh_flags))
685                 goto out_nolayout;
686         list_for_each_entry_safe(lseg, tmp, &lo->plh_segs, pls_list)
687                 if (test_bit(NFS_LSEG_ROC, &lseg->pls_flags)) {
688                         mark_lseg_invalid(lseg, &tmp_list);
689                         found = true;
690                 }
691         if (!found)
692                 goto out_nolayout;
693         lo->plh_block_lgets++;
694         get_layout_hdr(lo); /* matched in pnfs_roc_release */
695         spin_unlock(&ino->i_lock);
696         pnfs_free_lseg_list(&tmp_list);
697         return true;
698 
699 out_nolayout:
700         spin_unlock(&ino->i_lock);
701         return false;
702 }
703 
704 void pnfs_roc_release(struct inode *ino)
705 {
706         struct pnfs_layout_hdr *lo;
707 
708         spin_lock(&ino->i_lock);
709         lo = NFS_I(ino)->layout;
710         lo->plh_block_lgets--;
711         put_layout_hdr_locked(lo);
712         spin_unlock(&ino->i_lock);
713 }
714 
715 void pnfs_roc_set_barrier(struct inode *ino, u32 barrier)
716 {
717         struct pnfs_layout_hdr *lo;
718 
719         spin_lock(&ino->i_lock);
720         lo = NFS_I(ino)->layout;
721         if ((int)(barrier - lo->plh_barrier) > 0)
722                 lo->plh_barrier = barrier;
723         spin_unlock(&ino->i_lock);
724 }
725 
726 bool pnfs_roc_drain(struct inode *ino, u32 *barrier)
727 {
728         struct nfs_inode *nfsi = NFS_I(ino);
729         struct pnfs_layout_segment *lseg;
730         bool found = false;
731 
732         spin_lock(&ino->i_lock);
733         list_for_each_entry(lseg, &nfsi->layout->plh_segs, pls_list)
734                 if (test_bit(NFS_LSEG_ROC, &lseg->pls_flags)) {
735                         found = true;
736                         break;
737                 }
738         if (!found) {
739                 struct pnfs_layout_hdr *lo = nfsi->layout;
740                 u32 current_seqid = be32_to_cpu(lo->plh_stateid.stateid.seqid);
741 
742                 /* Since close does not return a layout stateid for use as
743                  * a barrier, we choose the worst-case barrier.
744                  */
745                 *barrier = current_seqid + atomic_read(&lo->plh_outstanding);
746         }
747         spin_unlock(&ino->i_lock);
748         return found;
749 }
750 
751 /*
752  * Compare two layout segments for sorting into layout cache.
753  * We want to preferentially return RW over RO layouts, so ensure those
754  * are seen first.
755  */
756 static s64
757 cmp_layout(struct pnfs_layout_range *l1,
758            struct pnfs_layout_range *l2)
759 {
760         s64 d;
761 
762         /* high offset > low offset */
763         d = l1->offset - l2->offset;
764         if (d)
765                 return d;
766 
767         /* short length > long length */
768         d = l2->length - l1->length;
769         if (d)
770                 return d;
771 
772         /* read > read/write */
773         return (int)(l1->iomode == IOMODE_READ) - (int)(l2->iomode == IOMODE_READ);
774 }
775 
776 static void
777 pnfs_insert_layout(struct pnfs_layout_hdr *lo,
778                    struct pnfs_layout_segment *lseg)
779 {
780         struct pnfs_layout_segment *lp;
781 
782         dprintk("%s:Begin\n", __func__);
783 
784         assert_spin_locked(&lo->plh_inode->i_lock);
785         list_for_each_entry(lp, &lo->plh_segs, pls_list) {
786                 if (cmp_layout(&lseg->pls_range, &lp->pls_range) > 0)
787                         continue;
788                 list_add_tail(&lseg->pls_list, &lp->pls_list);
789                 dprintk("%s: inserted lseg %p "
790                         "iomode %d offset %llu length %llu before "
791                         "lp %p iomode %d offset %llu length %llu\n",
792                         __func__, lseg, lseg->pls_range.iomode,
793                         lseg->pls_range.offset, lseg->pls_range.length,
794                         lp, lp->pls_range.iomode, lp->pls_range.offset,
795                         lp->pls_range.length);
796                 goto out;
797         }
798         list_add_tail(&lseg->pls_list, &lo->plh_segs);
799         dprintk("%s: inserted lseg %p "
800                 "iomode %d offset %llu length %llu at tail\n",
801                 __func__, lseg, lseg->pls_range.iomode,
802                 lseg->pls_range.offset, lseg->pls_range.length);
803 out:
804         get_layout_hdr(lo);
805 
806         dprintk("%s:Return\n", __func__);
807 }
808 
809 static struct pnfs_layout_hdr *
810 alloc_init_layout_hdr(struct inode *ino,
811                       struct nfs_open_context *ctx,
812                       gfp_t gfp_flags)
813 {
814         struct pnfs_layout_hdr *lo;
815 
816         lo = pnfs_alloc_layout_hdr(ino, gfp_flags);
817         if (!lo)
818                 return NULL;
819         atomic_set(&lo->plh_refcount, 1);
820         INIT_LIST_HEAD(&lo->plh_layouts);
821         INIT_LIST_HEAD(&lo->plh_segs);
822         INIT_LIST_HEAD(&lo->plh_bulk_recall);
823         lo->plh_inode = ino;
824         lo->plh_lc_cred = get_rpccred(ctx->state->owner->so_cred);
825         return lo;
826 }
827 
828 static struct pnfs_layout_hdr *
829 pnfs_find_alloc_layout(struct inode *ino,
830                        struct nfs_open_context *ctx,
831                        gfp_t gfp_flags)
832 {
833         struct nfs_inode *nfsi = NFS_I(ino);
834         struct pnfs_layout_hdr *new = NULL;
835 
836         dprintk("%s Begin ino=%p layout=%p\n", __func__, ino, nfsi->layout);
837 
838         assert_spin_locked(&ino->i_lock);
839         if (nfsi->layout) {
840                 if (test_bit(NFS_LAYOUT_DESTROYED, &nfsi->layout->plh_flags))
841                         return NULL;
842                 else
843                         return nfsi->layout;
844         }
845         spin_unlock(&ino->i_lock);
846         new = alloc_init_layout_hdr(ino, ctx, gfp_flags);
847         spin_lock(&ino->i_lock);
848 
849         if (likely(nfsi->layout == NULL))       /* Won the race? */
850                 nfsi->layout = new;
851         else
852                 pnfs_free_layout_hdr(new);
853         return nfsi->layout;
854 }
855 
856 /*
857  * iomode matching rules:
858  * iomode       lseg    match
859  * -----        -----   -----
860  * ANY          READ    true
861  * ANY          RW      true
862  * RW           READ    false
863  * RW           RW      true
864  * READ         READ    true
865  * READ         RW      true
866  */
867 static int
868 is_matching_lseg(struct pnfs_layout_range *ls_range,
869                  struct pnfs_layout_range *range)
870 {
871         struct pnfs_layout_range range1;
872 
873         if ((range->iomode == IOMODE_RW &&
874              ls_range->iomode != IOMODE_RW) ||
875             !lo_seg_intersecting(ls_range, range))
876                 return 0;
877 
878         /* range1 covers only the first byte in the range */
879         range1 = *range;
880         range1.length = 1;
881         return lo_seg_contained(ls_range, &range1);
882 }
883 
884 /*
885  * lookup range in layout
886  */
887 static struct pnfs_layout_segment *
888 pnfs_find_lseg(struct pnfs_layout_hdr *lo,
889                 struct pnfs_layout_range *range)
890 {
891         struct pnfs_layout_segment *lseg, *ret = NULL;
892 
893         dprintk("%s:Begin\n", __func__);
894 
895         assert_spin_locked(&lo->plh_inode->i_lock);
896         list_for_each_entry(lseg, &lo->plh_segs, pls_list) {
897                 if (test_bit(NFS_LSEG_VALID, &lseg->pls_flags) &&
898                     is_matching_lseg(&lseg->pls_range, range)) {
899                         ret = get_lseg(lseg);
900                         break;
901                 }
902                 if (lseg->pls_range.offset > range->offset)
903                         break;
904         }
905 
906         dprintk("%s:Return lseg %p ref %d\n",
907                 __func__, ret, ret ? atomic_read(&ret->pls_refcount) : 0);
908         return ret;
909 }
910 
911 /*
912  * Layout segment is retreived from the server if not cached.
913  * The appropriate layout segment is referenced and returned to the caller.
914  */
915 struct pnfs_layout_segment *
916 pnfs_update_layout(struct inode *ino,
917                    struct nfs_open_context *ctx,
918                    loff_t pos,
919                    u64 count,
920                    enum pnfs_iomode iomode,
921                    gfp_t gfp_flags)
922 {
923         struct pnfs_layout_range arg = {
924                 .iomode = iomode,
925                 .offset = pos,
926                 .length = count,
927         };
928         unsigned pg_offset;
929         struct nfs_inode *nfsi = NFS_I(ino);
930         struct nfs_client *clp = NFS_SERVER(ino)->nfs_client;
931         struct pnfs_layout_hdr *lo;
932         struct pnfs_layout_segment *lseg = NULL;
933         bool first = false;
934 
935         if (!pnfs_enabled_sb(NFS_SERVER(ino)))
936                 return NULL;
937         spin_lock(&ino->i_lock);
938         lo = pnfs_find_alloc_layout(ino, ctx, gfp_flags);
939         if (lo == NULL) {
940                 dprintk("%s ERROR: can't get pnfs_layout_hdr\n", __func__);
941                 goto out_unlock;
942         }
943 
944         /* Do we even need to bother with this? */
945         if (test_bit(NFS4CLNT_LAYOUTRECALL, &clp->cl_state) ||
946             test_bit(NFS_LAYOUT_BULK_RECALL, &lo->plh_flags)) {
947                 dprintk("%s matches recall, use MDS\n", __func__);
948                 goto out_unlock;
949         }
950 
951         /* if LAYOUTGET already failed once we don't try again */
952         if (test_bit(lo_fail_bit(iomode), &nfsi->layout->plh_flags))
953                 goto out_unlock;
954 
955         /* Check to see if the layout for the given range already exists */
956         lseg = pnfs_find_lseg(lo, &arg);
957         if (lseg)
958                 goto out_unlock;
959 
960         if (pnfs_layoutgets_blocked(lo, NULL, 0))
961                 goto out_unlock;
962         atomic_inc(&lo->plh_outstanding);
963 
964         get_layout_hdr(lo);
965         if (list_empty(&lo->plh_segs))
966                 first = true;
967         spin_unlock(&ino->i_lock);
968         if (first) {
969                 /* The lo must be on the clp list if there is any
970                  * chance of a CB_LAYOUTRECALL(FILE) coming in.
971                  */
972                 spin_lock(&clp->cl_lock);
973                 BUG_ON(!list_empty(&lo->plh_layouts));
974                 list_add_tail(&lo->plh_layouts, &clp->cl_layouts);
975                 spin_unlock(&clp->cl_lock);
976         }
977 
978         pg_offset = arg.offset & ~PAGE_CACHE_MASK;
979         if (pg_offset) {
980                 arg.offset -= pg_offset;
981                 arg.length += pg_offset;
982         }
983         if (arg.length != NFS4_MAX_UINT64)
984                 arg.length = PAGE_CACHE_ALIGN(arg.length);
985 
986         lseg = send_layoutget(lo, ctx, &arg, gfp_flags);
987         if (!lseg && first) {
988                 spin_lock(&clp->cl_lock);
989                 list_del_init(&lo->plh_layouts);
990                 spin_unlock(&clp->cl_lock);
991         }
992         atomic_dec(&lo->plh_outstanding);
993         put_layout_hdr(lo);
994 out:
995         dprintk("%s end, state 0x%lx lseg %p\n", __func__,
996                 nfsi->layout ? nfsi->layout->plh_flags : -1, lseg);
997         return lseg;
998 out_unlock:
999         spin_unlock(&ino->i_lock);
1000         goto out;
1001 }
1002 
1003 int
1004 pnfs_layout_process(struct nfs4_layoutget *lgp)
1005 {
1006         struct pnfs_layout_hdr *lo = NFS_I(lgp->args.inode)->layout;
1007         struct nfs4_layoutget_res *res = &lgp->res;
1008         struct pnfs_layout_segment *lseg;
1009         struct inode *ino = lo->plh_inode;
1010         struct nfs_client *clp = NFS_SERVER(ino)->nfs_client;
1011         int status = 0;
1012 
1013         /* Inject layout blob into I/O device driver */
1014         lseg = NFS_SERVER(ino)->pnfs_curr_ld->alloc_lseg(lo, res, lgp->gfp_flags);
1015         if (!lseg || IS_ERR(lseg)) {
1016                 if (!lseg)
1017                         status = -ENOMEM;
1018                 else
1019                         status = PTR_ERR(lseg);
1020                 dprintk("%s: Could not allocate layout: error %d\n",
1021                        __func__, status);
1022                 goto out;
1023         }
1024 
1025         spin_lock(&ino->i_lock);
1026         if (test_bit(NFS4CLNT_LAYOUTRECALL, &clp->cl_state) ||
1027             test_bit(NFS_LAYOUT_BULK_RECALL, &lo->plh_flags)) {
1028                 dprintk("%s forget reply due to recall\n", __func__);
1029                 goto out_forget_reply;
1030         }
1031 
1032         if (pnfs_layoutgets_blocked(lo, &res->stateid, 1)) {
1033                 dprintk("%s forget reply due to state\n", __func__);
1034                 goto out_forget_reply;
1035         }
1036         init_lseg(lo, lseg);
1037         lseg->pls_range = res->range;
1038         *lgp->lsegpp = get_lseg(lseg);
1039         pnfs_insert_layout(lo, lseg);
1040 
1041         if (res->return_on_close) {
1042                 set_bit(NFS_LSEG_ROC, &lseg->pls_flags);
1043                 set_bit(NFS_LAYOUT_ROC, &lo->plh_flags);
1044         }
1045 
1046         /* Done processing layoutget. Set the layout stateid */
1047         pnfs_set_layout_stateid(lo, &res->stateid, false);
1048         spin_unlock(&ino->i_lock);
1049 out:
1050         return status;
1051 
1052 out_forget_reply:
1053         spin_unlock(&ino->i_lock);
1054         lseg->pls_layout = lo;
1055         NFS_SERVER(ino)->pnfs_curr_ld->free_lseg(lseg);
1056         goto out;
1057 }
1058 
1059 bool
1060 pnfs_generic_pg_test(struct nfs_pageio_descriptor *pgio, struct nfs_page *prev,
1061                      struct nfs_page *req)
1062 {
1063         enum pnfs_iomode access_type;
1064         gfp_t gfp_flags;
1065 
1066         /* We assume that pg_ioflags == 0 iff we're reading a page */
1067         if (pgio->pg_ioflags == 0) {
1068                 access_type = IOMODE_READ;
1069                 gfp_flags = GFP_KERNEL;
1070         } else {
1071                 access_type = IOMODE_RW;
1072                 gfp_flags = GFP_NOFS;
1073         }
1074 
1075         if (pgio->pg_lseg == NULL) {
1076                 if (pgio->pg_count != prev->wb_bytes)
1077                         return true;
1078                 /* This is first coelesce call for a series of nfs_pages */
1079                 pgio->pg_lseg = pnfs_update_layout(pgio->pg_inode,
1080                                                    prev->wb_context,
1081                                                    req_offset(prev),
1082                                                    pgio->pg_count,
1083                                                    access_type,
1084                                                    gfp_flags);
1085                 if (pgio->pg_lseg == NULL)
1086                         return true;
1087         }
1088 
1089         /*
1090          * Test if a nfs_page is fully contained in the pnfs_layout_range.
1091          * Note that this test makes several assumptions:
1092          * - that the previous nfs_page in the struct nfs_pageio_descriptor
1093          *   is known to lie within the range.
1094          *   - that the nfs_page being tested is known to be contiguous with the
1095          *   previous nfs_page.
1096          *   - Layout ranges are page aligned, so we only have to test the
1097          *   start offset of the request.
1098          *
1099          * Please also note that 'end_offset' is actually the offset of the
1100          * first byte that lies outside the pnfs_layout_range. FIXME?
1101          *
1102          */
1103         return req_offset(req) < end_offset(pgio->pg_lseg->pls_range.offset,
1104                                          pgio->pg_lseg->pls_range.length);
1105 }
1106 EXPORT_SYMBOL_GPL(pnfs_generic_pg_test);
1107 
1108 /*
1109  * Called by non rpc-based layout drivers
1110  */
1111 int
1112 pnfs_ld_write_done(struct nfs_write_data *data)
1113 {
1114         int status;
1115 
1116         if (!data->pnfs_error) {
1117                 pnfs_set_layoutcommit(data);
1118                 data->mds_ops->rpc_call_done(&data->task, data);
1119                 data->mds_ops->rpc_release(data);
1120                 return 0;
1121         }
1122         if (NFS_SERVER(data->inode)->pnfs_curr_ld->flags &
1123                                         PNFS_LAYOUTRET_ON_ERROR) {
1124                 /* Don't lo_commit on error, Server will needs to
1125                  * preform a file recovery.
1126                  */
1127                 clear_bit(NFS_INO_LAYOUTCOMMIT, &NFS_I(data->inode)->flags);
1128                 pnfs_return_layout(data->inode);
1129         }
1130 
1131         dprintk("%s: pnfs_error=%d, retry via MDS\n", __func__,
1132                 data->pnfs_error);
1133         status = nfs_initiate_write(data, NFS_CLIENT(data->inode),
1134                                     data->mds_ops, NFS_FILE_SYNC);
1135         return status ? : -EAGAIN;
1136 }
1137 EXPORT_SYMBOL_GPL(pnfs_ld_write_done);
1138 
1139 enum pnfs_try_status
1140 pnfs_try_to_write_data(struct nfs_write_data *wdata,
1141                         const struct rpc_call_ops *call_ops, int how)
1142 {
1143         struct inode *inode = wdata->inode;
1144         enum pnfs_try_status trypnfs;
1145         struct nfs_server *nfss = NFS_SERVER(inode);
1146 
1147         wdata->mds_ops = call_ops;
1148 
1149         dprintk("%s: Writing ino:%lu %u@%llu (how %d)\n", __func__,
1150                 inode->i_ino, wdata->args.count, wdata->args.offset, how);
1151 
1152         trypnfs = nfss->pnfs_curr_ld->write_pagelist(wdata, how);
1153         if (trypnfs == PNFS_NOT_ATTEMPTED) {
1154                 put_lseg(wdata->lseg);
1155                 wdata->lseg = NULL;
1156         } else
1157                 nfs_inc_stats(inode, NFSIOS_PNFS_WRITE);
1158 
1159         dprintk("%s End (trypnfs:%d)\n", __func__, trypnfs);
1160         return trypnfs;
1161 }
1162 
1163 /*
1164  * Called by non rpc-based layout drivers
1165  */
1166 int
1167 pnfs_ld_read_done(struct nfs_read_data *data)
1168 {
1169         int status;
1170 
1171         if (!data->pnfs_error) {
1172                 __nfs4_read_done_cb(data);
1173                 data->mds_ops->rpc_call_done(&data->task, data);
1174                 data->mds_ops->rpc_release(data);
1175                 return 0;
1176         }
1177 
1178         if (NFS_SERVER(data->inode)->pnfs_curr_ld->flags &
1179                                                 PNFS_LAYOUTRET_ON_ERROR)
1180                 pnfs_return_layout(data->inode);
1181 
1182         dprintk("%s: pnfs_error=%d, retry via MDS\n", __func__,
1183                 data->pnfs_error);
1184         status = nfs_initiate_read(data, NFS_CLIENT(data->inode),
1185                                    data->mds_ops);
1186         return status ? : -EAGAIN;
1187 }
1188 EXPORT_SYMBOL_GPL(pnfs_ld_read_done);
1189 
1190 /*
1191  * Call the appropriate parallel I/O subsystem read function.
1192  */
1193 enum pnfs_try_status
1194 pnfs_try_to_read_data(struct nfs_read_data *rdata,
1195                        const struct rpc_call_ops *call_ops)
1196 {
1197         struct inode *inode = rdata->inode;
1198         struct nfs_server *nfss = NFS_SERVER(inode);
1199         enum pnfs_try_status trypnfs;
1200 
1201         rdata->mds_ops = call_ops;
1202 
1203         dprintk("%s: Reading ino:%lu %u@%llu\n",
1204                 __func__, inode->i_ino, rdata->args.count, rdata->args.offset);
1205 
1206         trypnfs = nfss->pnfs_curr_ld->read_pagelist(rdata);
1207         if (trypnfs == PNFS_NOT_ATTEMPTED) {
1208                 put_lseg(rdata->lseg);
1209                 rdata->lseg = NULL;
1210         } else {
1211                 nfs_inc_stats(inode, NFSIOS_PNFS_READ);
1212         }
1213         dprintk("%s End (trypnfs:%d)\n", __func__, trypnfs);
1214         return trypnfs;
1215 }
1216 
1217 /*
1218  * There can be multiple RW segments.
1219  */
1220 static void pnfs_list_write_lseg(struct inode *inode, struct list_head *listp)
1221 {
1222         struct pnfs_layout_segment *lseg;
1223 
1224         list_for_each_entry(lseg, &NFS_I(inode)->layout->plh_segs, pls_list) {
1225                 if (lseg->pls_range.iomode == IOMODE_RW &&
1226                     test_bit(NFS_LSEG_LAYOUTCOMMIT, &lseg->pls_flags))
1227                         list_add(&lseg->pls_lc_list, listp);
1228         }
1229 }
1230 
1231 void
1232 pnfs_set_layoutcommit(struct nfs_write_data *wdata)
1233 {
1234         struct nfs_inode *nfsi = NFS_I(wdata->inode);
1235         loff_t end_pos = wdata->mds_offset + wdata->res.count;
1236         bool mark_as_dirty = false;
1237 
1238         spin_lock(&nfsi->vfs_inode.i_lock);
1239         if (!test_and_set_bit(NFS_INO_LAYOUTCOMMIT, &nfsi->flags)) {
1240                 mark_as_dirty = true;
1241                 dprintk("%s: Set layoutcommit for inode %lu ",
1242                         __func__, wdata->inode->i_ino);
1243         }
1244         if (!test_and_set_bit(NFS_LSEG_LAYOUTCOMMIT, &wdata->lseg->pls_flags)) {
1245                 /* references matched in nfs4_layoutcommit_release */
1246                 get_lseg(wdata->lseg);
1247         }
1248         if (end_pos > nfsi->layout->plh_lwb)
1249                 nfsi->layout->plh_lwb = end_pos;
1250         spin_unlock(&nfsi->vfs_inode.i_lock);
1251         dprintk("%s: lseg %p end_pos %llu\n",
1252                 __func__, wdata->lseg, nfsi->layout->plh_lwb);
1253 
1254         /* if pnfs_layoutcommit_inode() runs between inode locks, the next one
1255          * will be a noop because NFS_INO_LAYOUTCOMMIT will not be set */
1256         if (mark_as_dirty)
1257                 mark_inode_dirty_sync(wdata->inode);
1258 }
1259 EXPORT_SYMBOL_GPL(pnfs_set_layoutcommit);
1260 
1261 /*
1262  * For the LAYOUT4_NFSV4_1_FILES layout type, NFS_DATA_SYNC WRITEs and
1263  * NFS_UNSTABLE WRITEs with a COMMIT to data servers must store enough
1264  * data to disk to allow the server to recover the data if it crashes.
1265  * LAYOUTCOMMIT is only needed when the NFL4_UFLG_COMMIT_THRU_MDS flag
1266  * is off, and a COMMIT is sent to a data server, or
1267  * if WRITEs to a data server return NFS_DATA_SYNC.
1268  */
1269 int
1270 pnfs_layoutcommit_inode(struct inode *inode, bool sync)
1271 {
1272         struct nfs4_layoutcommit_data *data;
1273         struct nfs_inode *nfsi = NFS_I(inode);
1274         loff_t end_pos;
1275         int status = 0;
1276 
1277         dprintk("--> %s inode %lu\n", __func__, inode->i_ino);
1278 
1279         if (!test_bit(NFS_INO_LAYOUTCOMMIT, &nfsi->flags))
1280                 return 0;
1281 
1282         /* Note kzalloc ensures data->res.seq_res.sr_slot == NULL */
1283         data = kzalloc(sizeof(*data), GFP_NOFS);
1284         if (!data) {
1285                 mark_inode_dirty_sync(inode);
1286                 status = -ENOMEM;
1287                 goto out;
1288         }
1289 
1290         INIT_LIST_HEAD(&data->lseg_list);
1291         spin_lock(&inode->i_lock);
1292         if (!test_and_clear_bit(NFS_INO_LAYOUTCOMMIT, &nfsi->flags)) {
1293                 spin_unlock(&inode->i_lock);
1294                 kfree(data);
1295                 goto out;
1296         }
1297 
1298         pnfs_list_write_lseg(inode, &data->lseg_list);
1299 
1300         end_pos = nfsi->layout->plh_lwb;
1301         nfsi->layout->plh_lwb = 0;
1302 
1303         memcpy(&data->args.stateid.data, nfsi->layout->plh_stateid.data,
1304                 sizeof(nfsi->layout->plh_stateid.data));
1305         spin_unlock(&inode->i_lock);
1306 
1307         data->args.inode = inode;
1308         data->cred = get_rpccred(nfsi->layout->plh_lc_cred);
1309         nfs_fattr_init(&data->fattr);
1310         data->args.bitmask = NFS_SERVER(inode)->cache_consistency_bitmask;
1311         data->res.fattr = &data->fattr;
1312         data->args.lastbytewritten = end_pos - 1;
1313         data->res.server = NFS_SERVER(inode);
1314 
1315         status = nfs4_proc_layoutcommit(data, sync);
1316 out:
1317         dprintk("<-- %s status %d\n", __func__, status);
1318         return status;
1319 }
1320 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp