1 files changed, 104 insertions, 8 deletions

diff --git a/drivers/infiniband/core/cache.c b/drivers/infiniband/core/cache.c
index 87471ef37198..89bebeada38b 100644
--- a/drivers/infiniband/core/cache.c
+++ b/drivers/infiniband/core/cache.c
@@ -409,10 +409,10 @@ static int ib_cache_gid_find(struct ib_device *ib_dev,
                                         mask, port, index);
 }
 
-int ib_cache_gid_find_by_port(struct ib_device *ib_dev,
-                              const union ib_gid *gid,
-                              u8 port, struct net_device *ndev,
-                              u16 *index)
+int ib_find_cached_gid_by_port(struct ib_device *ib_dev,
+                               const union ib_gid *gid,
+                               u8 port, struct net_device *ndev,
+                               u16 *index)
 {
         int local_index;
         struct ib_gid_table **ports_table = ib_dev->cache.gid_cache;
@@ -438,6 +438,82 @@ int ib_cache_gid_find_by_port(struct ib_device *ib_dev,
 
         return -ENOENT;
 }
+EXPORT_SYMBOL(ib_find_cached_gid_by_port);
+
+/**
+ * ib_find_gid_by_filter - Returns the GID table index where a specified
+ * GID value occurs
+ * @device: The device to query.
+ * @gid: The GID value to search for.
+ * @port_num: The port number of the device where the GID value could be
+ *   searched.
+ * @filter: The filter function is executed on any matching GID in the table.
+ *   If the filter function returns true, the corresponding index is returned,
+ *   otherwise, we continue searching the GID table. It's guaranteed that
+ *   while filter is executed, ndev field is valid and the structure won't
+ *   change. filter is executed in an atomic context. filter must not be NULL.
+ * @index: The index into the cached GID table where the GID was found.  This
+ *   parameter may be NULL.
+ *
+ * ib_cache_gid_find_by_filter() searches for the specified GID value
+ * of which the filter function returns true in the port's GID table.
+ * This function is only supported on RoCE ports.
+ *
+ */
+static int ib_cache_gid_find_by_filter(struct ib_device *ib_dev,
+                                       const union ib_gid *gid,
+                                       u8 port,
+                                       bool (*filter)(const union ib_gid *,
+                                                      const struct ib_gid_attr *,
+                                                      void *),
+                                       void *context,
+                                       u16 *index)
+{
+        struct ib_gid_table **ports_table = ib_dev->cache.gid_cache;
+        struct ib_gid_table *table;
+        unsigned int i;
+        bool found = false;
+
+        if (!ports_table)
+                return -EOPNOTSUPP;
+
+        if (port < rdma_start_port(ib_dev) ||
+            port > rdma_end_port(ib_dev) ||
+            !rdma_protocol_roce(ib_dev, port))
+                return -EPROTONOSUPPORT;
+
+        table = ports_table[port - rdma_start_port(ib_dev)];
+
+        for (i = 0; i < table->sz; i++) {
+                struct ib_gid_attr attr;
+                unsigned long flags;
+
+                read_lock_irqsave(&table->data_vec[i].lock, flags);
+                if (table->data_vec[i].props & GID_TABLE_ENTRY_INVALID)
+                        goto next;
+
+                if (memcmp(gid, &table->data_vec[i].gid, sizeof(*gid)))
+                        goto next;
+
+                memcpy(&attr, &table->data_vec[i].attr, sizeof(attr));
+
+                if (filter(gid, &attr, context))
+                        found = true;
+
+next:
+                read_unlock_irqrestore(&table->data_vec[i].lock, flags);
+
+                if (found)
+                        break;
+        }
+
+        if (!found)
+                return -ENOENT;
+
+        if (index)
+                *index = i;
+        return 0;
+}
 
 static struct ib_gid_table *alloc_gid_table(int sz)
 {
@@ -649,24 +725,44 @@ static int gid_table_setup_one(struct ib_device *ib_dev)
 int ib_get_cached_gid(struct ib_device *device,
                       u8                port_num,
                       int               index,
-                      union ib_gid     *gid)
+                      union ib_gid     *gid,
+                      struct ib_gid_attr *gid_attr)
 {
         if (port_num < rdma_start_port(device) || port_num > rdma_end_port(device))
                 return -EINVAL;
 
-        return __ib_cache_gid_get(device, port_num, index, gid, NULL);
+        return __ib_cache_gid_get(device, port_num, index, gid, gid_attr);
 }
 EXPORT_SYMBOL(ib_get_cached_gid);
 
 int ib_find_cached_gid(struct ib_device *device,
                        const union ib_gid *gid,
+                       struct net_device *ndev,
                        u8               *port_num,
                        u16              *index)
 {
-        return ib_cache_gid_find(device, gid, NULL, port_num, index);
+        return ib_cache_gid_find(device, gid, ndev, port_num, index);
 }
 EXPORT_SYMBOL(ib_find_cached_gid);
 
+int ib_find_gid_by_filter(struct ib_device *device,
+                          const union ib_gid *gid,
+                          u8 port_num,
+                          bool (*filter)(const union ib_gid *gid,
+                                         const struct ib_gid_attr *,
+                                         void *),
+                          void *context, u16 *index)
+{
+        /* Only RoCE GID table supports filter function */
+        if (!rdma_cap_roce_gid_table(device, port_num) && filter)
+                return -EPROTONOSUPPORT;
+
+        return ib_cache_gid_find_by_filter(device, gid,
+                                           port_num, filter,
+                                           context, index);
+}
+EXPORT_SYMBOL(ib_find_gid_by_filter);
+
 int ib_get_cached_pkey(struct ib_device *device,
                        u8                port_num,
                        int               index,
@@ -845,7 +941,7 @@ static void ib_cache_update(struct ib_device *device,
         if (!use_roce_gid_table) {
                 for (i = 0;  i < gid_cache->table_len; ++i) {
                         ret = ib_query_gid(device, port, i,
-                                           gid_cache->table + i);
+                                           gid_cache->table + i, NULL);
                         if (ret) {
                                 printk(KERN_WARNING "ib_query_gid failed (%d) for %s (index %d)\n",
                                        ret, device->name, i);