powerpc/pseries: Add support for hash table resizing

This adds support for using two hypercalls to change the size of the
main hash page table while running as a PAPR guest. For now these
hypercalls are only in experimental qemu versions.

The interface is two part: first H_RESIZE_HPT_PREPARE is used to
allocate and prepare the new hash table. This may be slow, but can be
done asynchronously. Then, H_RESIZE_HPT_COMMIT is used to switch to the
new hash table. This requires that no CPUs be concurrently updating the
HPT, and so must be run under stop_machine().

This also adds a debugfs file which can be used to manually control
HPT resizing or testing purposes.

Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
Reviewed-by: Paul Mackerras <paulus@samba.org>
[mpe: Rename the debugfs file to "hpt_order"]
Signed-off-by: Michael Ellerman <mpe@ellerman.id.au>

3 files changed, 143 insertions, 0 deletions

diff --git a/arch/powerpc/include/asm/book3s/64/mmu-hash.h b/arch/powerpc/include/asm/book3s/64/mmu-hash.h
index 823015cff149..52d8d1e4b772 100644
--- a/arch/powerpc/include/asm/book3s/64/mmu-hash.h
+++ b/arch/powerpc/include/asm/book3s/64/mmu-hash.h
@@ -157,6 +157,7 @@ struct mmu_hash_ops {
                                                unsigned long addr,
                                                unsigned char *hpte_slot_array,
                                                int psize, int ssize, int local);
+        int             (*resize_hpt)(unsigned long shift);
         /*
          * Special for kexec.
          * To be called in real mode with interrupts disabled. No locks are
diff --git a/arch/powerpc/mm/hash_utils_64.c b/arch/powerpc/mm/hash_utils_64.c
index 67e19a0821be..a3371d4e35b6 100644
--- a/arch/powerpc/mm/hash_utils_64.c
+++ b/arch/powerpc/mm/hash_utils_64.c
@@ -35,7 +35,9 @@
 #include <linux/memblock.h>
 #include <linux/context_tracking.h>
 #include <linux/libfdt.h>
+#include <linux/debugfs.h>
 
+#include <asm/debug.h>
 #include <asm/processor.h>
 #include <asm/pgtable.h>
 #include <asm/mmu.h>
@@ -1795,3 +1797,34 @@ void hash__setup_initial_memory_limit(phys_addr_t first_memblock_base,
         /* Finally limit subsequent allocations */
         memblock_set_current_limit(ppc64_rma_size);
 }
+
+#ifdef CONFIG_DEBUG_FS
+
+static int hpt_order_get(void *data, u64 *val)
+{
+        *val = ppc64_pft_size;
+        return 0;
+}
+
+static int hpt_order_set(void *data, u64 val)
+{
+        if (!mmu_hash_ops.resize_hpt)
+                return -ENODEV;
+
+        return mmu_hash_ops.resize_hpt(val);
+}
+
+DEFINE_SIMPLE_ATTRIBUTE(fops_hpt_order, hpt_order_get, hpt_order_set, "%llu\n");
+
+static int __init hash64_debugfs(void)
+{
+        if (!debugfs_create_file("hpt_order", 0600, powerpc_debugfs_root,
+                                 NULL, &fops_hpt_order)) {
+                pr_err("lpar: unable to create hpt_order debugsfs file\n");
+        }
+
+        return 0;
+}
+machine_device_initcall(pseries, hash64_debugfs);
+
+#endif /* CONFIG_DEBUG_FS */
diff --git a/arch/powerpc/platforms/pseries/lpar.c b/arch/powerpc/platforms/pseries/lpar.c
index 5dc1c3c6e716..c2e13a51f369 100644
--- a/arch/powerpc/platforms/pseries/lpar.c
+++ b/arch/powerpc/platforms/pseries/lpar.c
@@ -27,6 +27,8 @@
 #include <linux/console.h>
 #include <linux/export.h>
 #include <linux/jump_label.h>
+#include <linux/delay.h>
+#include <linux/stop_machine.h>
 #include <asm/processor.h>
 #include <asm/mmu.h>
 #include <asm/page.h>
@@ -609,6 +611,112 @@ static int __init disable_bulk_remove(char *str)
 
 __setup("bulk_remove=", disable_bulk_remove);
 
+#define HPT_RESIZE_TIMEOUT      10000 /* ms */
+
+struct hpt_resize_state {
+        unsigned long shift;
+        int commit_rc;
+};
+
+static int pseries_lpar_resize_hpt_commit(void *data)
+{
+        struct hpt_resize_state *state = data;
+
+        state->commit_rc = plpar_resize_hpt_commit(0, state->shift);
+        if (state->commit_rc != H_SUCCESS)
+                return -EIO;
+
+        /* Hypervisor has transitioned the HTAB, update our globals */
+        ppc64_pft_size = state->shift;
+        htab_size_bytes = 1UL << ppc64_pft_size;
+        htab_hash_mask = (htab_size_bytes >> 7) - 1;
+
+        return 0;
+}
+
+/* Must be called in user context */
+static int pseries_lpar_resize_hpt(unsigned long shift)
+{
+        struct hpt_resize_state state = {
+                .shift = shift,
+                .commit_rc = H_FUNCTION,
+        };
+        unsigned int delay, total_delay = 0;
+        int rc;
+        ktime_t t0, t1, t2;
+
+        might_sleep();
+
+        if (!firmware_has_feature(FW_FEATURE_HPT_RESIZE))
+                return -ENODEV;
+
+        printk(KERN_INFO "lpar: Attempting to resize HPT to shift %lu\n",
+               shift);
+
+        t0 = ktime_get();
+
+        rc = plpar_resize_hpt_prepare(0, shift);
+        while (H_IS_LONG_BUSY(rc)) {
+                delay = get_longbusy_msecs(rc);
+                total_delay += delay;
+                if (total_delay > HPT_RESIZE_TIMEOUT) {
+                        /* prepare with shift==0 cancels an in-progress resize */
+                        rc = plpar_resize_hpt_prepare(0, 0);
+                        if (rc != H_SUCCESS)
+                                printk(KERN_WARNING
+                                       "lpar: Unexpected error %d cancelling timed out HPT resize\n",
+                                       rc);
+                        return -ETIMEDOUT;
+                }
+                msleep(delay);
+                rc = plpar_resize_hpt_prepare(0, shift);
+        };
+
+        switch (rc) {
+        case H_SUCCESS:
+                /* Continue on */
+                break;
+
+        case H_PARAMETER:
+                return -EINVAL;
+        case H_RESOURCE:
+                return -EPERM;
+        default:
+                printk(KERN_WARNING
+                       "lpar: Unexpected error %d from H_RESIZE_HPT_PREPARE\n",
+                       rc);
+                return -EIO;
+        }
+
+        t1 = ktime_get();
+
+        rc = stop_machine(pseries_lpar_resize_hpt_commit, &state, NULL);
+
+        t2 = ktime_get();
+
+        if (rc != 0) {
+                switch (state.commit_rc) {
+                case H_PTEG_FULL:
+                        printk(KERN_WARNING
+                               "lpar: Hash collision while resizing HPT\n");
+                        return -ENOSPC;
+
+                default:
+                        printk(KERN_WARNING
+                               "lpar: Unexpected error %d from H_RESIZE_HPT_COMMIT\n",
+                               state.commit_rc);
+                        return -EIO;
+                };
+        }
+
+        printk(KERN_INFO
+               "lpar: HPT resize to shift %lu complete (%lld ms / %lld ms)\n",
+               shift, (long long) ktime_ms_delta(t1, t0),
+               (long long) ktime_ms_delta(t2, t1));
+
+        return 0;
+}
+
 void __init hpte_init_pseries(void)
 {
         mmu_hash_ops.hpte_invalidate     = pSeries_lpar_hpte_invalidate;
@@ -620,6 +728,7 @@ void __init hpte_init_pseries(void)
         mmu_hash_ops.flush_hash_range    = pSeries_lpar_flush_hash_range;
         mmu_hash_ops.hpte_clear_all      = pseries_hpte_clear_all;
         mmu_hash_ops.hugepage_invalidate = pSeries_lpar_hugepage_invalidate;
+        mmu_hash_ops.resize_hpt          = pseries_lpar_resize_hpt;
 }
 
 #ifdef CONFIG_PPC_SMLPAR