pnfs: Use byte-range for layoutget

Add offset and count parameters to pnfs_update_layout and use them to get
the layout in the pageio path.

Order cache layout segments in the following order:
* offset (ascending)
* length (descending)
* iomode (RW before READ)

Test byte range against the layout segment in use in pnfs_{read,write}_pg_test
so not to coalesce pages not using the same layout segment.

[fix lseg ordering]
[clean up pnfs_find_lseg lseg arg]
[remove unnecessary FIXME]
[fix ordering in pnfs_insert_layout]
[clean up pnfs_insert_layout]
Signed-off-by: Benny Halevy <bhalevy@panasas.com>

4 files changed, 142 insertions, 45 deletions

diff --git a/fs/nfs/pnfs.c b/fs/nfs/pnfs.c
index f57f5281a520..c2f09e9b670e 100644
--- a/fs/nfs/pnfs.c
+++ b/fs/nfs/pnfs.c
@@ -261,6 +261,65 @@ put_lseg(struct pnfs_layout_segment *lseg)
 }
 EXPORT_SYMBOL_GPL(put_lseg);
 
+static inline u64
+end_offset(u64 start, u64 len)
+{
+        u64 end;
+
+        end = start + len;
+        return end >= start ? end : NFS4_MAX_UINT64;
+}
+
+/* last octet in a range */
+static inline u64
+last_byte_offset(u64 start, u64 len)
+{
+        u64 end;
+
+        BUG_ON(!len);
+        end = start + len;
+        return end > start ? end - 1 : NFS4_MAX_UINT64;
+}
+
+/*
+ * is l2 fully contained in l1?
+ *   start1                             end1
+ *   [----------------------------------)
+ *           start2           end2
+ *           [----------------)
+ */
+static inline int
+lo_seg_contained(struct pnfs_layout_range *l1,
+                 struct pnfs_layout_range *l2)
+{
+        u64 start1 = l1->offset;
+        u64 end1 = end_offset(start1, l1->length);
+        u64 start2 = l2->offset;
+        u64 end2 = end_offset(start2, l2->length);
+
+        return (start1 <= start2) && (end1 >= end2);
+}
+
+/*
+ * is l1 and l2 intersecting?
+ *   start1                             end1
+ *   [----------------------------------)
+ *                              start2           end2
+ *                              [----------------)
+ */
+static inline int
+lo_seg_intersecting(struct pnfs_layout_range *l1,
+                    struct pnfs_layout_range *l2)
+{
+        u64 start1 = l1->offset;
+        u64 end1 = end_offset(start1, l1->length);
+        u64 start2 = l2->offset;
+        u64 end2 = end_offset(start2, l2->length);
+
+        return (end1 == NFS4_MAX_UINT64 || end1 > start2) &&
+               (end2 == NFS4_MAX_UINT64 || end2 > start1);
+}
+
 static bool
 should_free_lseg(u32 lseg_iomode, u32 recall_iomode)
 {
@@ -467,7 +526,7 @@ pnfs_choose_layoutget_stateid(nfs4_stateid *dst, struct pnfs_layout_hdr *lo,
 static struct pnfs_layout_segment *
 send_layoutget(struct pnfs_layout_hdr *lo,
            struct nfs_open_context *ctx,
-           u32 iomode,
+           struct pnfs_layout_range *range,
            gfp_t gfp_flags)
 {
         struct inode *ino = lo->plh_inode;
@@ -499,11 +558,11 @@ send_layoutget(struct pnfs_layout_hdr *lo,
                         goto out_err_free;
         }
 
-        lgp->args.minlength = NFS4_MAX_UINT64;
+        lgp->args.minlength = PAGE_CACHE_SIZE;
+        if (lgp->args.minlength > range->length)
+                lgp->args.minlength = range->length;
         lgp->args.maxcount = PNFS_LAYOUT_MAXSIZE;
-        lgp->args.range.iomode = iomode;
-        lgp->args.range.offset = 0;
-        lgp->args.range.length = NFS4_MAX_UINT64;
+        lgp->args.range = *range;
         lgp->args.type = server->pnfs_curr_ld->id;
         lgp->args.inode = ino;
         lgp->args.ctx = get_nfs_open_context(ctx);
@@ -518,7 +577,7 @@ send_layoutget(struct pnfs_layout_hdr *lo,
         nfs4_proc_layoutget(lgp);
         if (!lseg) {
                 /* remember that LAYOUTGET failed and suspend trying */
-                set_bit(lo_fail_bit(iomode), &lo->plh_flags);
+                set_bit(lo_fail_bit(range->iomode), &lo->plh_flags);
         }
 
         /* free xdr pages */
@@ -625,10 +684,23 @@ bool pnfs_roc_drain(struct inode *ino, u32 *barrier)
  * are seen first.
  */
 static s64
-cmp_layout(u32 iomode1, u32 iomode2)
+cmp_layout(struct pnfs_layout_range *l1,
+           struct pnfs_layout_range *l2)
 {
+        s64 d;
+
+        /* high offset > low offset */
+        d = l1->offset - l2->offset;
+        if (d)
+                return d;
+
+        /* short length > long length */
+        d = l2->length - l1->length;
+        if (d)
+                return d;
+
         /* read > read/write */
-        return (int)(iomode2 == IOMODE_READ) - (int)(iomode1 == IOMODE_READ);
+        return (int)(l1->iomode == IOMODE_READ) - (int)(l2->iomode == IOMODE_READ);
 }
 
 static void
@@ -636,13 +708,12 @@ pnfs_insert_layout(struct pnfs_layout_hdr *lo,
                    struct pnfs_layout_segment *lseg)
 {
         struct pnfs_layout_segment *lp;
-        int found = 0;
 
         dprintk("%s:Begin\n", __func__);
 
         assert_spin_locked(&lo->plh_inode->i_lock);
         list_for_each_entry(lp, &lo->plh_segs, pls_list) {
-                if (cmp_layout(lp->pls_range.iomode, lseg->pls_range.iomode) > 0)
+                if (cmp_layout(&lseg->pls_range, &lp->pls_range) > 0)
                         continue;
                 list_add_tail(&lseg->pls_list, &lp->pls_list);
                 dprintk("%s: inserted lseg %p "
@@ -652,16 +723,14 @@ pnfs_insert_layout(struct pnfs_layout_hdr *lo,
                         lseg->pls_range.offset, lseg->pls_range.length,
                         lp, lp->pls_range.iomode, lp->pls_range.offset,
                         lp->pls_range.length);
-                found = 1;
-                break;
-        }
-        if (!found) {
-                list_add_tail(&lseg->pls_list, &lo->plh_segs);
-                dprintk("%s: inserted lseg %p "
-                        "iomode %d offset %llu length %llu at tail\n",
-                        __func__, lseg, lseg->pls_range.iomode,
-                        lseg->pls_range.offset, lseg->pls_range.length);
+                goto out;
         }
+        list_add_tail(&lseg->pls_list, &lo->plh_segs);
+        dprintk("%s: inserted lseg %p "
+                "iomode %d offset %llu length %llu at tail\n",
+                __func__, lseg, lseg->pls_range.iomode,
+                lseg->pls_range.offset, lseg->pls_range.length);
+out:
         get_layout_hdr(lo);
 
         dprintk("%s:Return\n", __func__);
@@ -721,16 +790,28 @@ pnfs_find_alloc_layout(struct inode *ino, gfp_t gfp_flags)
  * READ         RW      true
  */
 static int
-is_matching_lseg(struct pnfs_layout_segment *lseg, u32 iomode)
+is_matching_lseg(struct pnfs_layout_range *ls_range,
+                 struct pnfs_layout_range *range)
 {
-        return (iomode != IOMODE_RW || lseg->pls_range.iomode == IOMODE_RW);
+        struct pnfs_layout_range range1;
+
+        if ((range->iomode == IOMODE_RW &&
+             ls_range->iomode != IOMODE_RW) ||