nfs: remove dead code for the old swap over NFS implementation

Remove the code testing folio_test_swapcache either explicitly or
implicitly in pagemap.h headers, as is now handled using the direct I/O
path and not the buffered I/O path that these helpers are located in.

Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Sagi Grimberg <sagi@grimberg.me>
Signed-off-by: Anna Schumaker <Anna.Schumaker@Netapp.com>

diff --git a/fs/nfs/file.c b/fs/nfs/file.c
index 834e612262e62b551c296874ad7de33258dc7da1..0e2f87120cb840a53d4d8ae856c5ea64fa040612 100644 (file)
--- a/fs/nfs/file.c
+++ b/fs/nfs/file.c
@@ -427,7 +427,7 @@ static int nfs_write_end(struct file *file, struct address_space *mapping,
 static void nfs_invalidate_folio(struct folio *folio, size_t offset,
                                size_t length)
 {
-       struct inode *inode = folio_file_mapping(folio)->host;
+       struct inode *inode = folio->mapping->host;
        dfprintk(PAGECACHE, "NFS: invalidate_folio(%lu, %zu, %zu)\n",
                 folio->index, offset, length);
 
@@ -454,7 +454,7 @@ static bool nfs_release_folio(struct folio *folio, gfp_t gfp)
                if ((current_gfp_context(gfp) & GFP_KERNEL) != GFP_KERNEL ||
                    current_is_kswapd())
                        return false;
-               if (nfs_wb_folio(folio_file_mapping(folio)->host, folio) < 0)
+               if (nfs_wb_folio(folio->mapping->host, folio) < 0)
                        return false;
        }
        return nfs_fscache_release_folio(folio, gfp);
@@ -606,7 +606,7 @@ static vm_fault_t nfs_vm_page_mkwrite(struct vm_fault *vmf)
                           TASK_KILLABLE|TASK_FREEZABLE_UNSAFE);
 
        folio_lock(folio);
-       mapping = folio_file_mapping(folio);
+       mapping = folio->mapping;
        if (mapping != inode->i_mapping)
                goto out_unlock;
 

diff --git a/fs/nfs/filelayout/filelayout.c b/fs/nfs/filelayout/filelayout.c
index 29d84dc66ca391f90879ca9dd424c0d0344d5101..b6e9aeaf4ce289c96252f240c3dacc7ddcc000af 100644 (file)
--- a/fs/nfs/filelayout/filelayout.c
+++ b/fs/nfs/filelayout/filelayout.c
@@ -1110,7 +1110,6 @@ static const struct pnfs_commit_ops filelayout_commit_ops = {
        .clear_request_commit   = pnfs_generic_clear_request_commit,
        .scan_commit_lists      = pnfs_generic_scan_commit_lists,
        .recover_commit_reqs    = pnfs_generic_recover_commit_reqs,
-       .search_commit_reqs     = pnfs_generic_search_commit_reqs,
        .commit_pagelist        = filelayout_commit_pagelist,
 };
 

diff --git a/fs/nfs/fscache.c b/fs/nfs/fscache.c
index ddc1ee0319554cfc381bc920acb248766938bde7..7202ce84d0eb032784e241fa8a82e79486948d49 100644 (file)
--- a/fs/nfs/fscache.c
+++ b/fs/nfs/fscache.c
@@ -341,7 +341,7 @@ void nfs_netfs_initiate_read(struct nfs_pgio_header *hdr)
 
 int nfs_netfs_folio_unlock(struct folio *folio)
 {
-       struct inode *inode = folio_file_mapping(folio)->host;
+       struct inode *inode = folio->mapping->host;
 
        /*
         * If fscache is enabled, netfs will unlock pages.

diff --git a/fs/nfs/internal.h b/fs/nfs/internal.h
index 9f0f4534744ba4d10050d13559a115b7ccd617cc..87ebc4608c316a6e5291fd40871b5e6d8c6c792f 100644 (file)
--- a/fs/nfs/internal.h
+++ b/fs/nfs/internal.h
@@ -785,7 +785,7 @@ static inline void nfs_folio_mark_unstable(struct folio *folio,
                                           struct nfs_commit_info *cinfo)
 {
        if (folio && !cinfo->dreq) {
-               struct inode *inode = folio_file_mapping(folio)->host;
+               struct inode *inode = folio->mapping->host;
                long nr = folio_nr_pages(folio);
 
                /* This page is really still in write-back - just that the
@@ -803,7 +803,7 @@ static inline void nfs_folio_mark_unstable(struct folio *folio,
 static inline
 unsigned int nfs_page_length(struct page *page)
 {
-       loff_t i_size = i_size_read(page_file_mapping(page)->host);
+       loff_t i_size = i_size_read(page->mapping->host);
 
        if (i_size > 0) {
                pgoff_t index = page_index(page);
@@ -821,10 +821,10 @@ unsigned int nfs_page_length(struct page *page)
  */
 static inline size_t nfs_folio_length(struct folio *folio)
 {
-       loff_t i_size = i_size_read(folio_file_mapping(folio)->host);
+       loff_t i_size = i_size_read(folio->mapping->host);
 
        if (i_size > 0) {
-               pgoff_t index = folio_index(folio) >> folio_order(folio);
+               pgoff_t index = folio->index >> folio_order(folio);
                pgoff_t end_index = (i_size - 1) >> folio_shift(folio);
                if (index < end_index)
                        return folio_size(folio);

diff --git a/fs/nfs/pagelist.c b/fs/nfs/pagelist.c
index 040b6b79c75e599c1d2860250b94e63309e77ea4..3b006bcbcc87a20cfec3fefda0ac9261bed5f99a 100644 (file)
--- a/fs/nfs/pagelist.c
+++ b/fs/nfs/pagelist.c
@@ -569,7 +569,7 @@ struct nfs_page *nfs_page_create_from_folio(struct nfs_open_context *ctx,
 
        if (IS_ERR(l_ctx))
                return ERR_CAST(l_ctx);
-       ret = nfs_page_create(l_ctx, offset, folio_index(folio), offset, count);
+       ret = nfs_page_create(l_ctx, offset, folio->index, offset, count);
        if (!IS_ERR(ret)) {
                nfs_page_assign_folio(ret, folio);
                nfs_page_group_init(ret, NULL);

diff --git a/fs/nfs/pnfs.h b/fs/nfs/pnfs.h
index bb5142b4e67a5999bfe433f589b3b42e5b8da29a..1fc40afcbf1f506462d7c5fd2f060a4a99ff3457 100644 (file)
--- a/fs/nfs/pnfs.h
+++ b/fs/nfs/pnfs.h
@@ -199,8 +199,6 @@ struct pnfs_commit_ops {
                                  int max);
        void (*recover_commit_reqs) (struct list_head *list,
                                     struct nfs_commit_info *cinfo);
-       struct nfs_page * (*search_commit_reqs)(struct nfs_commit_info *cinfo,
-                                               struct folio *folio);
 };
 
 struct pnfs_layout_hdr {
@@ -409,8 +407,6 @@ void pnfs_generic_prepare_to_resend_writes(struct nfs_commit_data *data);
 void pnfs_generic_rw_release(void *data);
 void pnfs_generic_recover_commit_reqs(struct list_head *dst,
                                      struct nfs_commit_info *cinfo);
-struct nfs_page *pnfs_generic_search_commit_reqs(struct nfs_commit_info *cinfo,
-                                                struct folio *folio);
 int pnfs_generic_commit_pagelist(struct inode *inode,
                                 struct list_head *mds_pages,
                                 int how,
@@ -570,17 +566,6 @@ pnfs_recover_commit_reqs(struct list_head *head, struct nfs_commit_info *cinfo)
                fl_cinfo->ops->recover_commit_reqs(head, cinfo);
 }
 
-static inline struct nfs_page *
-pnfs_search_commit_reqs(struct inode *inode, struct nfs_commit_info *cinfo,
-                       struct folio *folio)
-{
-       struct pnfs_ds_commit_info *fl_cinfo = cinfo->ds;
-
-       if (!fl_cinfo->ops || !fl_cinfo->ops->search_commit_reqs)
-               return NULL;
-       return fl_cinfo->ops->search_commit_reqs(cinfo, folio);
-}
-
 /* Should the pNFS client commit and return the layout upon a setattr */
 static inline bool
 pnfs_ld_layoutret_on_setattr(struct inode *inode)
@@ -882,13 +867,6 @@ pnfs_recover_commit_reqs(struct list_head *head, struct nfs_commit_info *cinfo)
 {
 }
 
-static inline struct nfs_page *
-pnfs_search_commit_reqs(struct inode *inode, struct nfs_commit_info *cinfo,
-                       struct folio *folio)
-{
-       return NULL;
-}
-
 static inline int pnfs_layoutcommit_inode(struct inode *inode, bool sync)
 {
        return 0;

diff --git a/fs/nfs/pnfs_nfs.c b/fs/nfs/pnfs_nfs.c
index 88e061bd711b746afcd46878e518f870fae19b0c..a74ee69a2fa63848823c065fc22e80e8a2ad3c46 100644 (file)
--- a/fs/nfs/pnfs_nfs.c
+++ b/fs/nfs/pnfs_nfs.c
@@ -351,53 +351,6 @@ void pnfs_generic_recover_commit_reqs(struct list_head *dst,
 }
 EXPORT_SYMBOL_GPL(pnfs_generic_recover_commit_reqs);
 
-static struct nfs_page *
-pnfs_bucket_search_commit_reqs(struct pnfs_commit_bucket *buckets,
-                              unsigned int nbuckets, struct folio *folio)
-{
-       struct nfs_page *req;
-       struct pnfs_commit_bucket *b;
-       unsigned int i;
-
-       /* Linearly search the commit lists for each bucket until a matching
-        * request is found */
-       for (i = 0, b = buckets; i < nbuckets; i++, b++) {
-               list_for_each_entry(req, &b->written, wb_list) {
-                       if (nfs_page_to_folio(req) == folio)
-                               return req->wb_head;
-               }
-               list_for_each_entry(req, &b->committing, wb_list) {
-                       if (nfs_page_to_folio(req) == folio)
-                               return req->wb_head;
-               }
-       }
-       return NULL;
-}
-
-/* pnfs_generic_search_commit_reqs - Search lists in @cinfo for the head request
- *                                for @folio
- * @cinfo - commit info for current inode
- * @folio - page to search for matching head request
- *
- * Return: the head request if one is found, otherwise %NULL.
- */
-struct nfs_page *pnfs_generic_search_commit_reqs(struct nfs_commit_info *cinfo,
-                                                struct folio *folio)
-{
-       struct pnfs_ds_commit_info *fl_cinfo = cinfo->ds;
-       struct pnfs_commit_array *array;
-       struct nfs_page *req;
-
-       list_for_each_entry(array, &fl_cinfo->commits, cinfo_list) {
-               req = pnfs_bucket_search_commit_reqs(array->buckets,
-                                                    array->nbuckets, folio);
-               if (req)
-                       return req;
-       }
-       return NULL;
-}
-EXPORT_SYMBOL_GPL(pnfs_generic_search_commit_reqs);
-
 static struct pnfs_layout_segment *
 pnfs_bucket_get_committing(struct list_head *head,
                           struct pnfs_commit_bucket *bucket,

diff --git a/fs/nfs/read.c b/fs/nfs/read.c
index 1b0e06c11983cb462ad47864c332396ed993770c..036ede4875cab6a15107385d1935528ff7d1b82d 100644 (file)
--- a/fs/nfs/read.c
+++ b/fs/nfs/read.c
@@ -289,7 +289,7 @@ int nfs_read_add_folio(struct nfs_pageio_descriptor *pgio,
                       struct nfs_open_context *ctx,
                       struct folio *folio)
 {
-       struct inode *inode = folio_file_mapping(folio)->host;
+       struct inode *inode = folio->mapping->host;
        struct nfs_server *server = NFS_SERVER(inode);
        size_t fsize = folio_size(folio);
        unsigned int rsize = server->rsize;

diff --git a/fs/nfs/write.c b/fs/nfs/write.c
index 81845ab2e00a049d7ad5185a5a1d31facd3460e3..dc432f581fa773369fde5e639ec41ce8a448a8d2 100644 (file)
--- a/fs/nfs/write.c
+++ b/fs/nfs/write.c
@@ -63,9 +63,6 @@ static void nfs_clear_request_commit(struct nfs_commit_info *cinfo,
                                     struct nfs_page *req);
 static void nfs_init_cinfo_from_inode(struct nfs_commit_info *cinfo,
                                      struct inode *inode);
-static struct nfs_page *
-nfs_page_search_commits_for_head_request_locked(struct nfs_inode *nfsi,
-                                               struct folio *folio);
 
 static struct kmem_cache *nfs_wdata_cachep;
 static mempool_t *nfs_wdata_mempool;
@@ -178,16 +175,16 @@ static struct nfs_page *nfs_folio_private_request(struct folio *folio)
 }
 
 /**
- * nfs_folio_find_private_request - find head request associated with a folio
+ * nfs_folio_find_head_request - find head request associated with a folio
  * @folio: pointer to folio
  *
  * must be called while holding the inode lock.
  *
  * returns matching head request with reference held, or NULL if not found.
  */
-static struct nfs_page *nfs_folio_find_private_request(struct folio *folio)
+static struct nfs_page *nfs_folio_find_head_request(struct folio *folio)
 {
-       struct address_space *mapping = folio_file_mapping(folio);
+       struct address_space *mapping = folio->mapping;
        struct nfs_page *req;
 
        if (!folio_test_private(folio))
@@ -202,45 +199,9 @@ static struct nfs_page *nfs_folio_find_private_request(struct folio *folio)
        return req;
 }
 
-static struct nfs_page *nfs_folio_find_swap_request(struct folio *folio)
-{
-       struct inode *inode = folio_file_mapping(folio)->host;
-       struct nfs_inode *nfsi = NFS_I(inode);
-       struct nfs_page *req = NULL;
-       if (!folio_test_swapcache(folio))
-               return NULL;
-       mutex_lock(&nfsi->commit_mutex);
-       if (folio_test_swapcache(folio)) {
-               req = nfs_page_search_commits_for_head_request_locked(nfsi,
-                                                                     folio);
-               if (req) {
-                       WARN_ON_ONCE(req->wb_head != req);
-                       kref_get(&req->wb_kref);
-               }
-       }
-       mutex_unlock(&nfsi->commit_mutex);
-       return req;
-}
-
-/**
- * nfs_folio_find_head_request - find head request associated with a folio
- * @folio: pointer to folio
- *
- * returns matching head request with reference held, or NULL if not found.
- */
-static struct nfs_page *nfs_folio_find_head_request(struct folio *folio)
-{
-       struct nfs_page *req;
-
-       req = nfs_folio_find_private_request(folio);
-       if (!req)
-               req = nfs_folio_find_swap_request(folio);
-       return req;
-}
-
 static struct nfs_page *nfs_folio_find_and_lock_request(struct folio *folio)
 {
-       struct inode *inode = folio_file_mapping(folio)->host;
+       struct inode *inode = folio->mapping->host;
        struct nfs_page *req, *head;
        int ret;
 
@@ -261,8 +222,6 @@ static struct nfs_page *nfs_folio_find_and_lock_request(struct folio *folio)
                /* Ensure that nobody removed the request before we locked it */
                if (head == nfs_folio_private_request(folio))
                        break;
-               if (folio_test_swapcache(folio))
-                       break;
                nfs_unlock_and_release_request(head);
        }
        return head;
@@ -272,14 +231,14 @@ static struct nfs_page *nfs_folio_find_and_lock_request(struct folio *folio)
 static void nfs_grow_file(struct folio *folio, unsigned int offset,
                          unsigned int count)
 {
-       struct inode *inode = folio_file_mapping(folio)->host;
+       struct inode *inode = folio->mapping->host;
        loff_t end, i_size;
        pgoff_t end_index;
 
        spin_lock(&inode->i_lock);
        i_size = i_size_read(inode);
        end_index = ((i_size - 1) >> folio_shift(folio)) << folio_order(folio);
-       if (i_size > 0 && folio_index(folio) < end_index)
+       if (i_size > 0 && folio->index < end_index)
                goto out;
        end = folio_file_pos(folio) + (loff_t)offset + (loff_t)count;
        if (i_size >= end)
@@ -311,7 +270,7 @@ static void nfs_set_pageerror(struct address_space *mapping)
 
 static void nfs_mapping_set_error(struct folio *folio, int error)
 {
-       struct address_space *mapping = folio_file_mapping(folio);
+       struct address_space *mapping = folio->mapping;
 
        folio_set_error(folio);
        filemap_set_wb_err(mapping, error);
@@ -412,7 +371,7 @@ int nfs_congestion_kb;
 
 static void nfs_folio_set_writeback(struct folio *folio)
 {
-       struct nfs_server *nfss = NFS_SERVER(folio_file_mapping(folio)->host);
+       struct nfs_server *nfss = NFS_SERVER(folio->mapping->host);
 
        folio_start_writeback(folio);
        if (atomic_long_inc_return(&nfss->writeback) > NFS_CONGESTION_ON_THRESH)
@@ -421,7 +380,7 @@ static void nfs_folio_set_writeback(struct folio *folio)
 
 static void nfs_folio_end_writeback(struct folio *folio)
 {
-       struct nfs_server *nfss = NFS_SERVER(folio_file_mapping(folio)->host);
+       struct nfs_server *nfss = NFS_SERVER(folio->mapping->host);
 
        folio_end_writeback(folio);
        if (atomic_long_dec_return(&nfss->writeback) <
@@ -569,7 +528,7 @@ void nfs_join_page_group(struct nfs_page *head, struct nfs_commit_info *cinfo,
  */
 static struct nfs_page *nfs_lock_and_join_requests(struct folio *folio)
 {
-       struct inode *inode = folio_file_mapping(folio)->host;
+       struct inode *inode = folio->mapping->host;
        struct nfs_page *head;
        struct nfs_commit_info cinfo;
        int ret;
@@ -645,7 +604,7 @@ static int nfs_page_async_flush(struct folio *folio,
                nfs_redirty_request(req);
                pgio->pg_error = 0;
        } else
-               nfs_add_stats(folio_file_mapping(folio)->host,
+               nfs_add_stats(folio->mapping->host,
                              NFSIOS_WRITEPAGES, 1);
 out:
        return ret;
@@ -657,7 +616,7 @@ out_launder:
 static int nfs_do_writepage(struct folio *folio, struct writeback_control *wbc,
                            struct nfs_pageio_descriptor *pgio)
 {
-       nfs_pageio_cond_complete(pgio, folio_index(folio));
+       nfs_pageio_cond_complete(pgio, folio->index);
        return nfs_page_async_flush(folio, wbc, pgio);
 }
 
@@ -668,7 +627,7 @@ static int nfs_writepage_locked(struct folio *folio,
                                struct writeback_control *wbc)
 {
        struct nfs_pageio_descriptor pgio;
-       struct inode *inode = folio_file_mapping(folio)->host;
+       struct inode *inode = folio->mapping->host;
        int err;
 
        nfs_inc_stats(inode, NFSIOS_VFSWRITEPAGE);
@@ -751,24 +710,17 @@ out_err:
 static void nfs_inode_add_request(struct nfs_page *req)
 {
        struct folio *folio = nfs_page_to_folio(req);
-       struct address_space *mapping = folio_file_mapping(folio);
+       struct address_space *mapping = folio->mapping;
        struct nfs_inode *nfsi = NFS_I(mapping->host);
 
        WARN_ON_ONCE(req->wb_this_page != req);
 
        /* Lock the request! */
        nfs_lock_request(req);
-
-       /*
-        * Swap-space should not get truncated. Hence no need to plug the race
-        * with invalidate/truncate.
-        */
        spin_lock(&mapping->i_private_lock);
-       if (likely(!folio_test_swapcache(folio))) {
-               set_bit(PG_MAPPED, &req->wb_flags);
-               folio_set_private(folio);
-               folio->private = req;
-       }
+       set_bit(PG_MAPPED, &req->wb_flags);
+       folio_set_private(folio);
+       folio->private = req;
        spin_unlock(&mapping->i_private_lock);
        atomic_long_inc(&nfsi->nrequests);
        /* this a head request for a page group - mark it as having an
@@ -788,10 +740,10 @@ static void nfs_inode_remove_request(struct nfs_page *req)
 
        if (nfs_page_group_sync_on_bit(req, PG_REMOVE)) {
                struct folio *folio = nfs_page_to_folio(req->wb_head);
-               struct address_space *mapping = folio_file_mapping(folio);
+               struct address_space *mapping = folio->mapping;
 
                spin_lock(&mapping->i_private_lock);
-               if (likely(folio && !folio_test_swapcache(folio))) {
+               if (likely(folio)) {
                        folio->private = NULL;
                        folio_clear_private(folio);
                        clear_bit(PG_MAPPED, &req->wb_head->wb_flags);
@@ -812,38 +764,6 @@ static void nfs_mark_request_dirty(struct nfs_page *req)
                filemap_dirty_folio(folio_mapping(folio), folio);
 }
 
-/*
- * nfs_page_search_commits_for_head_request_locked
- *
- * Search through commit lists on @inode for the head request for @folio.
- * Must be called while holding the inode (which is cinfo) lock.
- *
- * Returns the head request if found, or NULL if not found.
- */
-static struct nfs_page *
-nfs_page_search_commits_for_head_request_locked(struct nfs_inode *nfsi,
-                                               struct folio *folio)
-{
-       struct nfs_page *freq, *t;
-       struct nfs_commit_info cinfo;
-       struct inode *inode = &nfsi->vfs_inode;
-
-       nfs_init_cinfo_from_inode(&cinfo, inode);
-
-       /* search through pnfs commit lists */
-       freq = pnfs_search_commit_reqs(inode, &cinfo, folio);
-       if (freq)
-               return freq->wb_head;
-
-       /* Linearly search the commit list for the correct request */
-       list_for_each_entry_safe(freq, t, &cinfo.mds->list, wb_list) {
-               if (nfs_page_to_folio(freq) == folio)
-                       return freq->wb_head;
-       }
-
-       return NULL;
-}
-
 /**
  * nfs_request_add_commit_list_locked - add request to a commit list
  * @req: pointer to a struct nfs_page
@@ -950,7 +870,7 @@ static void nfs_folio_clear_commit(struct folio *folio)
                long nr = folio_nr_pages(folio);
 
                node_stat_mod_folio(folio, NR_WRITEBACK, -nr);
-               wb_stat_mod(&inode_to_bdi(folio_file_mapping(folio)->host)->wb,
+               wb_stat_mod(&inode_to_bdi(folio->mapping->host)->wb,
                            WB_WRITEBACK, -nr);
        }
 }
@@ -1135,7 +1055,7 @@ out_flushme:
         */
        nfs_mark_request_dirty(req);
        nfs_unlock_and_release_request(req);
-       error = nfs_wb_folio(folio_file_mapping(folio)->host, folio);
+       error = nfs_wb_folio(folio->mapping->host, folio);
        return (error < 0) ? ERR_PTR(error) : NULL;
 }
 
@@ -1211,7 +1131,7 @@ int nfs_flush_incompatible(struct file *file, struct folio *folio)
                nfs_release_request(req);
                if (!do_flush)
                        return 0;
-               status = nfs_wb_folio(folio_file_mapping(folio)->host, folio);
+               status = nfs_wb_folio(folio->mapping->host, folio);
        } while (status == 0);
        return status;
 }
@@ -1285,7 +1205,7 @@ out:
  */
 static bool nfs_folio_write_uptodate(struct folio *folio, unsigned int pagelen)
 {
-       struct inode *inode = folio_file_mapping(folio)->host;
+       struct inode *inode = folio->mapping->host;
        struct nfs_inode *nfsi = NFS_I(inode);
 
        if (nfs_have_delegated_attributes(inode))
@@ -1363,7 +1283,7 @@ int nfs_update_folio(struct file *file, struct folio *folio,
                     unsigned int offset, unsigned int count)
 {
        struct nfs_open_context *ctx = nfs_file_open_context(file);
-       struct address_space *mapping = folio_file_mapping(folio);
+       struct address_space *mapping = folio->mapping;
        struct inode *inode = mapping->host;
        unsigned int pagelen = nfs_folio_length(folio);
        int             status = 0;

diff --git a/include/linux/nfs_page.h b/include/linux/nfs_page.h
index 1c315f854ea8013bef87fb820dd0186aefb4a3cf..7bc31df457ea58fa712265e0a5dc99504851b9b5 100644 (file)
--- a/include/linux/nfs_page.h
+++ b/include/linux/nfs_page.h
@@ -208,8 +208,8 @@ static inline struct inode *nfs_page_to_inode(const struct nfs_page *req)
        struct folio *folio = nfs_page_to_folio(req);
 
        if (folio == NULL)
-               return page_file_mapping(req->wb_page)->host;
-       return folio_file_mapping(folio)->host;
+               return req->wb_page->mapping->host;
+       return folio->mapping->host;
 }
 
 /**