Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/roland/infiniband

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/roland/infiniband:
  IB/ehca: Reject dynamic memory add/remove when ehca adapter is present
  IB/ehca: Fix reported max number of QPs and CQs in systems with >1 adapter
  IPoIB: Set netdev offload features properly for child (VLAN) interfaces
  IPoIB: Clean up ethtool support
  mlx4_core: Add Ethernet PCI device IDs
  mlx4_en: Add driver for Mellanox ConnectX 10GbE NIC
  mlx4_core: Multiple port type support
  mlx4_core: Ethernet MAC/VLAN management
  mlx4_core: Get ethernet MTU and default address from firmware
  mlx4_core: Support multiple pre-reserved QP regions
  Update NetEffect maintainer emails to Intel emails
  RDMA/cxgb3: Remove cmid reference on tid allocation failures
  IB/mad: Use krealloc() to resize snoop table
  IPoIB: Always initialize poll_timer to avoid crash on unload
  IB/ehca: Don't allow creating UC QP with SRQ
  mlx4_core: Add QP range reservation support
  RDMA/ucma: Test ucma_alloc_multicast() return against NULL, not with IS_ERR()

1 files changed, 88 insertions, 9 deletions

diff --git a/drivers/net/mlx4/alloc.c b/drivers/net/mlx4/alloc.c
index b411b79d72ad..ad95d5f7b630 100644
--- a/drivers/net/mlx4/alloc.c
+++ b/drivers/net/mlx4/alloc.c
@@ -48,13 +48,16 @@ u32 mlx4_bitmap_alloc(struct mlx4_bitmap *bitmap)
 
         obj = find_next_zero_bit(bitmap->table, bitmap->max, bitmap->last);
         if (obj >= bitmap->max) {
-                bitmap->top = (bitmap->top + bitmap->max) & bitmap->mask;
+                bitmap->top = (bitmap->top + bitmap->max + bitmap->reserved_top)
+                                & bitmap->mask;
                 obj = find_first_zero_bit(bitmap->table, bitmap->max);
         }
 
         if (obj < bitmap->max) {
                 set_bit(obj, bitmap->table);
-                bitmap->last = (obj + 1) & (bitmap->max - 1);
+                bitmap->last = (obj + 1);
+                if (bitmap->last == bitmap->max)
+                        bitmap->last = 0;
                 obj |= bitmap->top;
         } else
                 obj = -1;
@@ -66,16 +69,90 @@ u32 mlx4_bitmap_alloc(struct mlx4_bitmap *bitmap)
 
 void mlx4_bitmap_free(struct mlx4_bitmap *bitmap, u32 obj)
 {
-        obj &= bitmap->max - 1;
+        mlx4_bitmap_free_range(bitmap, obj, 1);
+}
+
+static unsigned long find_aligned_range(unsigned long *bitmap,
+                                        u32 start, u32 nbits,
+                                        int len, int align)
+{
+        unsigned long end, i;
+
+again:
+        start = ALIGN(start, align);
+
+        while ((start < nbits) && test_bit(start, bitmap))
+                start += align;
+
+        if (start >= nbits)
+                return -1;
+
+        end = start+len;
+        if (end > nbits)
+                return -1;
+
+        for (i = start + 1; i < end; i++) {
+                if (test_bit(i, bitmap)) {
+                        start = i + 1;
+                        goto again;
+                }
+        }
+
+        return start;
+}
+
+u32 mlx4_bitmap_alloc_range(struct mlx4_bitmap *bitmap, int cnt, int align)
+{
+        u32 obj, i;
+
+        if (likely(cnt == 1 && align == 1))
+                return mlx4_bitmap_alloc(bitmap);
+
+        spin_lock(&bitmap->lock);
+
+        obj = find_aligned_range(bitmap->table, bitmap->last,
+                                 bitmap->max, cnt, align);
+        if (obj >= bitmap->max) {
+                bitmap->top = (bitmap->top + bitmap->max + bitmap->reserved_top)
+                                & bitmap->mask;
+                obj = find_aligned_range(bitmap->table, 0, bitmap->max,
+                                         cnt, align);
+        }
+
+        if (obj < bitmap->max) {
+                for (i = 0; i < cnt; i++)
+                        set_bit(obj + i, bitmap->table);
+                if (obj == bitmap->last) {
+                        bitmap->last = (obj + cnt);
+                        if (bitmap->last >= bitmap->max)
+                                bitmap->last = 0;
+                }
+                obj |= bitmap->top;
+        } else
+                obj = -1;
+
+        spin_unlock(&bitmap->lock);
+
+        return obj;
+}
+
+void mlx4_bitmap_free_range(struct mlx4_bitmap *bitmap, u32 obj, int cnt)
+{
+        u32 i;
+
+        obj &= bitmap->max + bitmap->reserved_top - 1;
 
         spin_lock(&bitmap->lock);
-        clear_bit(obj, bitmap->table);
+        for (i = 0; i < cnt; i++)
+                clear_bit(obj + i, bitmap->table);
         bitmap->last = min(bitmap->last, obj);
-        bitmap->top = (bitmap->top + bitmap->max) & bitmap->mask;
+        bitmap->top = (bitmap->top + bitmap->max + bitmap->reserved_top)
+                        & bitmap->mask;
         spin_unlock(&bitmap->lock);
 }
 
-int mlx4_bitmap_init(struct mlx4_bitmap *bitmap, u32 num, u32 mask, u32 reserved)
+int mlx4_bitmap_init(struct mlx4_bitmap *bitmap, u32 num, u32 mask,
+                     u32 reserved_bot, u32 reserved_top)
 {
         int i;
 
@@ -85,14 +162,16 @@ int mlx4_bitmap_init(struct mlx4_bitmap *bitmap, u32 num, u32 mask, u32 reserved
 
         bitmap->last = 0;
         bitmap->top  = 0;
-        bitmap->max  = num;
+        bitmap->max  = num - reserved_top;
         bitmap->mask = mask;
+        bitmap->reserved_top = reserved_top;
         spin_lock_init(&bitmap->lock);
-        bitmap->table = kzalloc(BITS_TO_LONGS(num) * sizeof (long), GFP_KERNEL);
+        bitmap->table = kzalloc(BITS_TO_LONGS(bitmap->max) *
+                                sizeof (long), GFP_KERNEL);
         if (!bitmap->table)
                 return -ENOMEM;
 
-        for (i = 0; i < reserved; ++i)
+        for (i = 0; i < reserved_bot; ++i)
                 set_bit(i, bitmap->table);
 
         return 0;