1 files changed, 104 insertions, 46 deletions

diff --git a/fs/nfs/pnfs_dev.c b/fs/nfs/pnfs_dev.c
index 6da209bd9408..aa2ec0015183 100644
--- a/fs/nfs/pnfs_dev.c
+++ b/fs/nfs/pnfs_dev.c
@@ -29,6 +29,9 @@
  */
 
 #include <linux/export.h>
+#include <linux/nfs_fs.h>
+#include "nfs4session.h"
+#include "internal.h"
 #include "pnfs.h"
 
 #define NFSDBG_FACILITY         NFSDBG_PNFS
@@ -89,6 +92,74 @@ _lookup_deviceid(const struct pnfs_layoutdriver_type *ld,
         return NULL;
 }
 
+static struct nfs4_deviceid_node *
+nfs4_get_device_info(struct nfs_server *server,
+                const struct nfs4_deviceid *dev_id,
+                struct rpc_cred *cred, gfp_t gfp_flags)
+{
+        struct nfs4_deviceid_node *d = NULL;
+        struct pnfs_device *pdev = NULL;
+        struct page **pages = NULL;
+        u32 max_resp_sz;
+        int max_pages;
+        int rc, i;
+
+        /*
+         * Use the session max response size as the basis for setting
+         * GETDEVICEINFO's maxcount
+         */
+        max_resp_sz = server->nfs_client->cl_session->fc_attrs.max_resp_sz;
+        if (server->pnfs_curr_ld->max_deviceinfo_size &&
+            server->pnfs_curr_ld->max_deviceinfo_size < max_resp_sz)
+                max_resp_sz = server->pnfs_curr_ld->max_deviceinfo_size;
+        max_pages = nfs_page_array_len(0, max_resp_sz);
+        dprintk("%s: server %p max_resp_sz %u max_pages %d\n",
+                __func__, server, max_resp_sz, max_pages);
+
+        pdev = kzalloc(sizeof(*pdev), gfp_flags);
+        if (!pdev)
+                return NULL;
+
+        pages = kcalloc(max_pages, sizeof(struct page *), gfp_flags);
+        if (!pages)
+                goto out_free_pdev;
+
+        for (i = 0; i < max_pages; i++) {
+                pages[i] = alloc_page(gfp_flags);
+                if (!pages[i])
+                        goto out_free_pages;
+        }
+
+        memcpy(&pdev->dev_id, dev_id, sizeof(*dev_id));
+        pdev->layout_type = server->pnfs_curr_ld->id;
+        pdev->pages = pages;
+        pdev->pgbase = 0;
+        pdev->pglen = max_resp_sz;
+        pdev->mincount = 0;
+        pdev->maxcount = max_resp_sz - nfs41_maxgetdevinfo_overhead;
+
+        rc = nfs4_proc_getdeviceinfo(server, pdev, cred);
+        dprintk("%s getdevice info returns %d\n", __func__, rc);
+        if (rc)
+                goto out_free_pages;
+
+        /*
+         * Found new device, need to decode it and then add it to the
+         * list of known devices for this mountpoint.
+         */
+        d = server->pnfs_curr_ld->alloc_deviceid_node(server, pdev,
+                        gfp_flags);
+
+out_free_pages:
+        for (i = 0; i < max_pages; i++)
+                __free_page(pages[i]);
+        kfree(pages);
+out_free_pdev:
+        kfree(pdev);
+        dprintk("<-- %s d %p\n", __func__, d);
+        return d;
+}
+
 /*
  * Lookup a deviceid in cache and get a reference count on it if found
  *
@@ -96,14 +167,14 @@ _lookup_deviceid(const struct pnfs_layoutdriver_type *ld,
  * @id deviceid to look up
  */
 static struct nfs4_deviceid_node *
-_find_get_deviceid(const struct pnfs_layoutdriver_type *ld,
-                   const struct nfs_client *clp, const struct nfs4_deviceid *id,
-                   long hash)
+__nfs4_find_get_deviceid(struct nfs_server *server,
+                const struct nfs4_deviceid *id, long hash)
 {
         struct nfs4_deviceid_node *d;
 
         rcu_read_lock();
-        d = _lookup_deviceid(ld, clp, id, hash);
+        d = _lookup_deviceid(server->pnfs_curr_ld, server->nfs_client, id,
+                        hash);
         if (d != NULL)
                 atomic_inc(&d->ref);
         rcu_read_unlock();
@@ -111,10 +182,33 @@ _find_get_deviceid(const struct pnfs_layoutdriver_type *ld,
 }
 
 struct nfs4_deviceid_node *
-nfs4_find_get_deviceid(const struct pnfs_layoutdriver_type *ld,
-                       const struct nfs_client *clp, const struct nfs4_deviceid *id)
+nfs4_find_get_deviceid(struct nfs_server *server,
+                const struct nfs4_deviceid *id, struct rpc_cred *cred,
+                gfp_t gfp_mask)
 {
-        return _find_get_deviceid(ld, clp, id, nfs4_deviceid_hash(id));
+        long hash = nfs4_deviceid_hash(id);
+        struct nfs4_deviceid_node *d, *new;
+
+        d = __nfs4_find_get_deviceid(server, id, hash);
+        if (d)
+                return d;
+
+        new = nfs4_get_device_info(server, id, cred, gfp_mask);
+        if (!new)
+                return new;
+
+        spin_lock(&nfs4_deviceid_lock);
+        d = __nfs4_find_get_deviceid(server, id, hash);
+        if (d) {
+                spin_unlock(&nfs4_deviceid_lock);
+                server->pnfs_curr_ld->free_deviceid_node(new);
+                return d;
+        }
+        hlist_add_head_rcu(&new->node, &nfs4_deviceid_cache[hash]);
+        atomic_inc(&new->ref);
+        spin_unlock(&nfs4_deviceid_lock);
+
+        return new;
 }
 EXPORT_SYMBOL_GPL(nfs4_find_get_deviceid);
 
@@ -151,15 +245,13 @@ nfs4_delete_deviceid(const struct pnfs_layoutdriver_type *ld,
 EXPORT_SYMBOL_GPL(nfs4_delete_deviceid);
 
 void
-nfs4_init_deviceid_node(struct nfs4_deviceid_node *d,
-                        const struct pnfs_layoutdriver_type *ld,
-                        const struct nfs_client *nfs_client,
+nfs4_init_deviceid_node(struct nfs4_deviceid_node *d, struct nfs_server *server,
                         const struct nfs4_deviceid *id)
 {
         INIT_HLIST_NODE(&d->node);
         INIT_HLIST_NODE(&d->tmpnode);
-        d->ld = ld;
-        d->nfs_client = nfs_client;
+        d->ld = server->pnfs_curr_ld;
+        d->nfs_client = server->nfs_client;
         d->flags = 0;
         d->deviceid = *id;
         atomic_set(&d->ref, 1);
@@ -167,39 +259,6 @@ nfs4_init_deviceid_node(struct nfs4_deviceid_node *d,
 EXPORT_SYMBOL_GPL(nfs4_init_deviceid_node);
 
 /*
- * Uniquely initialize and insert a deviceid node into cache
- *
- * @new new deviceid node
- *      Note that the caller must set up the following members:
- *        new->ld
- *        new->nfs_client
- *        new->deviceid
- *
- * @ret the inserted node, if none found, otherwise, the found entry.
- */
-struct nfs4_deviceid_node *
-nfs4_insert_deviceid_node(struct nfs4_deviceid_node *new)
-{
-        struct nfs4_deviceid_node *d;
-        long hash;
-
-        spin_lock(&nfs4_deviceid_lock);
-        hash = nfs4_deviceid_hash(&new->deviceid);
-        d = _find_get_deviceid(new->ld, new->nfs_client, &new->deviceid, hash);
-        if (d) {
-                spin_unlock(&nfs4_deviceid_lock);
-                return d;
-        }
-
-        hlist_add_head_rcu(&new->node, &nfs4_deviceid_cache[hash]);
-        spin_unlock(&nfs4_deviceid_lock);
-        atomic_inc(&new->ref);
-
-        return new;
-}
-EXPORT_SYMBOL_GPL(nfs4_insert_deviceid_node);
-
-/*
  * Dereference a deviceid node and delete it when its reference count drops
  * to zero.
  *
@@ -299,4 +358,3 @@ nfs4_deviceid_mark_client_invalid(struct nfs_client *clp)
         }
         rcu_read_unlock();
 }
-