fuse: handle U64_MAX correctly in DLM locked range index

When merging and checking overlap U64_MAX was not handled
this will create problems on multiple DLM results that cover
the whole range.

Add a fast path for adding and checking locked ranges when
the whole range is covered.

Signed-off-by: Horst Birthelmer <hbirthelmer@ddn.com>

Author: hbirth

fs/fuse/fuse_dlm_cache.c

@@ -8,6 +8,7 @@
 #include <linux/list.h>
 #include <linux/types.h>
 #include <linux/slab.h>
+#include <linux/limits.h>
 #include <linux/interval_tree_generic.h>
 
 
@@ -130,16 +131,16 @@ static void fuse_dlm_try_merge(struct fuse_dlm_cache *cache, uint64_t start,
 	node = rb_first_cached(&cache->ranges);
 	while (node) {
 		range = rb_entry(node, struct fuse_dlm_range, rb);
-		if (range->end >= start - 1)
+		if (start == 0 || range->end >= start - 1)
 			break;
 		node = rb_next(node);
 	}
 
-	if (!range || range->start > end + 1)
+	if (!range || (end != U64_MAX && range->start > end + 1))
 		return;
 
 	/* Try to merge ranges in and around the specified region */
-	while (range && range->start <= end + 1) {
+	while (range && (end == U64_MAX || range->start <= end + 1)) {
 		/* Get next range before we potentially modify the tree */
 		next = NULL;
 		if (rb_next(&range->rb)) {
@@ -149,9 +150,11 @@ static void fuse_dlm_try_merge(struct fuse_dlm_cache *cache, uint64_t start,
 
 		/* Try to merge with next range if adjacent and same mode */
 		if (next && range->mode == next->mode &&
-		    range->end + 1 == next->start) {
-			/* Merge ranges */
-			range->end = next->end;
+		    (range->end == U64_MAX || range->end + 1 == next->start)) {
+			/* Merge ranges - but can't merge if range->end is already U64_MAX */
+			if (range->end != U64_MAX) {
+				range->end = next->end;
+			}
 
 			/* Remove next from tree */
 			fuse_page_it_remove(next, &cache->ranges);
@@ -198,10 +201,25 @@ int fuse_dlm_lock_range(struct fuse_inode *inode, uint64_t start,
 
 	/* Convert to lock mode */
 	lock_mode = (mode == FUSE_PAGE_LOCK_READ) ? FUSE_PCACHE_LK_READ :
-						    FUSE_PCACHE_LK_WRITE;
+						     FUSE_PCACHE_LK_WRITE;
 
 	down_write(&cache->lock);
 
+	/*
+	 * Fast path: check if the requested range is already fully covered.
+	 * This is an optimization for the common case where we grant
+	 * [0, U64_MAX] locks and avoids overflow arithmetic.
+	 */
+	range = fuse_page_it_iter_first(&cache->ranges, start, end);
+	if (range && range->start <= start && range->end >= end) {
+		bool same_mode = (range->mode == lock_mode);
+		bool stronger_mode = (lock_mode == FUSE_PCACHE_LK_READ &&
+				      range->mode == FUSE_PCACHE_LK_WRITE);
+
+		if (same_mode || stronger_mode)
+			goto out;
+	}
+
 	/* Find all ranges that overlap with [start, end] */
 	range = fuse_page_it_iter_first(&cache->ranges, start, end);
 	while (range) {
@@ -270,6 +288,7 @@ int fuse_dlm_lock_range(struct fuse_inode *inode, uint64_t start,
 	/* Try to merge adjacent ranges with the same mode */
 	fuse_dlm_try_merge(cache, start, end);
 
+out:
 	up_write(&cache->lock);
 	return 0;
 
@@ -322,13 +341,25 @@ static int fuse_dlm_punch_hole(struct fuse_dlm_cache *cache, uint64_t start,
 
 	/* If the hole is at the beginning of the range */
 	if (start == range->start) {
-		range->start = end + 1;
+		if (end == U64_MAX) {
+			/* Hole goes to end of address space, remove entire range */
+			fuse_page_it_remove(range, &cache->ranges);
+			kfree(range);
+		} else {
+			range->start = end + 1;
+		}
 		goto out;
 	}
 
 	/* If the hole is at the end of the range */
 	if (end == range->end) {
-		range->end = start - 1;
+		if (start == 0) {
+			/* Hole starts at 0, remove entire range */
+			fuse_page_it_remove(range, &cache->ranges);
+			kfree(range);
+		} else {
+			range->end = start - 1;
+		}
 		goto out;
 	}
 
@@ -399,10 +430,10 @@ int fuse_dlm_unlock_range(struct fuse_inode *inode,
 			/* After punching a hole, we're done */
 			break;
 		} else if (start > range->start) {
-			/* Adjust the end of the range */
+			/* Adjust the end of the range (start is > 0, so start - 1 is safe) */
 			range->end = start - 1;
 		} else if (end < range->end) {
-			/* Adjust the start of the range */
+			/* Adjust the start of the range (end is < U64_MAX, so end + 1 is safe) */
 			range->start = end + 1;
 		} else {
 			/* Complete overlap, remove the range */
@@ -437,6 +468,7 @@ bool fuse_dlm_range_is_locked(struct fuse_inode *inode, uint64_t start,
 	struct fuse_dlm_range *range;
 	int lock_mode = 0;
 	uint64_t current_start = start;
+	bool ret = false;
 
 	if (!cache || start > end)
 		return false;
@@ -452,20 +484,34 @@ bool fuse_dlm_range_is_locked(struct fuse_inode *inode, uint64_t start,
 	/* Find the first range that overlaps with [start, end] */
 	range = fuse_dlm_find_overlapping(cache, start, end);
 
-	/* Check if the entire range is covered */
+	/*
+	 * Fast path: check if a single range covers the entire request.
+	 * This is common when we grant [0, U64_MAX] locks.
+	 */
+	if (range && range->start <= start && range->end >= end) {
+		/* Range fully covers [start, end] */
+		if (!lock_mode || range->mode == lock_mode) {
+			ret = true;
+			goto out;
+		}
+		/* Wrong lock mode */
+		goto out;
+	}
+
+	/* Slow path: check if multiple ranges cover the request */
 	while (range && current_start <= end) {
 		/* If we're checking for a specific mode, verify it matches */
-		if (lock_mode && range->mode != lock_mode) {
-			/* Wrong lock mode */
-			up_read(&cache->lock);
-			return false;
-		}
+		if (lock_mode && range->mode != lock_mode)
+			goto out;
 
 		/* Check if there's a gap before this range */
-		if (current_start < range->start) {
-			/* Found a gap */
-			up_read(&cache->lock);
-			return false;
+		if (current_start < range->start)
+			goto out;
+
+		if (range->end == U64_MAX) {
+			/* Range covers to end of address space */
+			ret = true;
+			goto out;
 		}
 
 		/* Move current_start past this range */
@@ -476,14 +522,11 @@ bool fuse_dlm_range_is_locked(struct fuse_inode *inode, uint64_t start,
 	}
 
 	/* Check if we covered the entire range */
-	if (current_start <= end) {
-		/* There's a gap at the end */
-		up_read(&cache->lock);
-		return false;
-	}
+	ret = (current_start > end);
 
+out:
 	up_read(&cache->lock);
-	return true;
+	return ret;
 }
 
 /**