arch/arm64/kernel/hibernate.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*:
   3  * Hibernate support specific for ARM64
   4  *
   5  * Derived from work on ARM hibernation support by:
   6  *
   7  * Ubuntu project, hibernation support for mach-dove
   8  * Copyright (C) 2010 Nokia Corporation (Hiroshi Doyu)
   9  * Copyright (C) 2010 Texas Instruments, Inc. (Teerth Reddy et al.)
  10  *  https://lkml.org/lkml/2010/6/18/4
  11  *  https://lists.linux-foundation.org/pipermail/linux-pm/2010-June/027422.html
  12  *  https://patchwork.kernel.org/patch/96442/
  13  *
  14  * Copyright (C) 2006 Rafael J. Wysocki <rjw@sisk.pl>
  15  */
  16 #define pr_fmt(x) "hibernate: " x
  17 #include <linux/cpu.h>
  18 #include <linux/kvm_host.h>
  19 #include <linux/mm.h>
  20 #include <linux/pm.h>
  21 #include <linux/sched.h>
  22 #include <linux/suspend.h>
  23 #include <linux/utsname.h>
  24 #include <linux/version.h>
  25
  26 #include <asm/barrier.h>
  27 #include <asm/cacheflush.h>
  28 #include <asm/cputype.h>
  29 #include <asm/daifflags.h>
  30 #include <asm/irqflags.h>
  31 #include <asm/kexec.h>
  32 #include <asm/memory.h>
  33 #include <asm/mmu_context.h>
  34 #include <asm/pgalloc.h>
  35 #include <asm/pgtable.h>
  36 #include <asm/pgtable-hwdef.h>
  37 #include <asm/sections.h>
  38 #include <asm/smp.h>
  39 #include <asm/smp_plat.h>
  40 #include <asm/suspend.h>
  41 #include <asm/sysreg.h>
  42 #include <asm/virt.h>
  43
  44 /*
  45  * Hibernate core relies on this value being 0 on resume, and marks it
  46  * __nosavedata assuming it will keep the resume kernel's '0' value. This
  47  * doesn't happen with either KASLR.
  48  *
  49  * defined as "__visible int in_suspend __nosavedata" in
  50  * kernel/power/hibernate.c
  51  */
  52 extern int in_suspend;
  53
  54 /* Do we need to reset el2? */
  55 #define el2_reset_needed() (is_hyp_mode_available() && !is_kernel_in_hyp_mode())
  56
  57 /* temporary el2 vectors in the __hibernate_exit_text section. */
  58 extern char hibernate_el2_vectors[];
  59
  60 /* hyp-stub vectors, used to restore el2 during resume from hibernate. */
  61 extern char __hyp_stub_vectors[];
  62
  63 /*
  64  * The logical cpu number we should resume on, initialised to a non-cpu
  65  * number.
  66  */
  67 static int sleep_cpu = -EINVAL;
  68
  69 /*
  70  * Values that may not change over hibernate/resume. We put the build number
  71  * and date in here so that we guarantee not to resume with a different
  72  * kernel.
  73  */
  74 struct arch_hibernate_hdr_invariants {
  75         char            uts_version[__NEW_UTS_LEN + 1];
  76 };
  77
  78 /* These values need to be know across a hibernate/restore. */
  79 static struct arch_hibernate_hdr {
  80         struct arch_hibernate_hdr_invariants invariants;
  81
  82         /* These are needed to find the relocated kernel if built with kaslr */
  83         phys_addr_t     ttbr1_el1;
  84         void            (*reenter_kernel)(void);
  85
  86         /*
  87          * We need to know where the __hyp_stub_vectors are after restore to
  88          * re-configure el2.
  89          */
  90         phys_addr_t     __hyp_stub_vectors;
  91
  92         u64             sleep_cpu_mpidr;
  93 } resume_hdr;
  94
  95 static inline void arch_hdr_invariants(struct arch_hibernate_hdr_invariants *i)
  96 {
  97         memset(i, 0, sizeof(*i));
  98         memcpy(i->uts_version, init_utsname()->version, sizeof(i->uts_version));
  99 }
 100
 101 int pfn_is_nosave(unsigned long pfn)
 102 {
 103         unsigned long nosave_begin_pfn = sym_to_pfn(&__nosave_begin);
 104         unsigned long nosave_end_pfn = sym_to_pfn(&__nosave_end - 1);
 105
 106         return ((pfn >= nosave_begin_pfn) && (pfn <= nosave_end_pfn)) ||
 107                 crash_is_nosave(pfn);
 108 }
 109
 110 void notrace save_processor_state(void)
 111 {
 112         WARN_ON(num_online_cpus() != 1);
 113 }
 114
 115 void notrace restore_processor_state(void)
 116 {
 117 }
 118
 119 int arch_hibernation_header_save(void *addr, unsigned int max_size)
 120 {
 121         struct arch_hibernate_hdr *hdr = addr;
 122
 123         if (max_size < sizeof(*hdr))
 124                 return -EOVERFLOW;
 125
 126         arch_hdr_invariants(&hdr->invariants);
 127         hdr->ttbr1_el1          = __pa_symbol(swapper_pg_dir);
 128         hdr->reenter_kernel     = _cpu_resume;
 129
 130         /* We can't use __hyp_get_vectors() because kvm may still be loaded */
 131         if (el2_reset_needed())
 132                 hdr->__hyp_stub_vectors = __pa_symbol(__hyp_stub_vectors);
 133         else
 134                 hdr->__hyp_stub_vectors = 0;
 135
 136         /* Save the mpidr of the cpu we called cpu_suspend() on... */
 137         if (sleep_cpu < 0) {
 138                 pr_err("Failing to hibernate on an unknown CPU.\n");
 139                 return -ENODEV;
 140         }
 141         hdr->sleep_cpu_mpidr = cpu_logical_map(sleep_cpu);
 142         pr_info("Hibernating on CPU %d [mpidr:0x%llx]\n", sleep_cpu,
 143                 hdr->sleep_cpu_mpidr);
 144
 145         return 0;
 146 }
 147 EXPORT_SYMBOL(arch_hibernation_header_save);
 148
 149 int arch_hibernation_header_restore(void *addr)
 150 {
 151         int ret;
 152         struct arch_hibernate_hdr_invariants invariants;
 153         struct arch_hibernate_hdr *hdr = addr;
 154
 155         arch_hdr_invariants(&invariants);
 156         if (memcmp(&hdr->invariants, &invariants, sizeof(invariants))) {
 157                 pr_crit("Hibernate image not generated by this kernel!\n");
 158                 return -EINVAL;
 159         }
 160
 161         sleep_cpu = get_logical_index(hdr->sleep_cpu_mpidr);
 162         pr_info("Hibernated on CPU %d [mpidr:0x%llx]\n", sleep_cpu,
 163                 hdr->sleep_cpu_mpidr);
 164         if (sleep_cpu < 0) {
 165                 pr_crit("Hibernated on a CPU not known to this kernel!\n");
 166                 sleep_cpu = -EINVAL;
 167                 return -EINVAL;
 168         }
 169
 170         ret = bringup_hibernate_cpu(sleep_cpu);
 171         if (ret) {
 172                 sleep_cpu = -EINVAL;
 173                 return ret;
 174         }
 175
 176         resume_hdr = *hdr;
 177
 178         return 0;
 179 }
 180 EXPORT_SYMBOL(arch_hibernation_header_restore);
 181
 182 static int trans_pgd_map_page(pgd_t *trans_pgd, void *page,
 183                        unsigned long dst_addr,
 184                        pgprot_t pgprot)
 185 {
 186         pgd_t *pgdp;
 187         pud_t *pudp;
 188         pmd_t *pmdp;
 189         pte_t *ptep;
 190
 191         pgdp = pgd_offset_raw(trans_pgd, dst_addr);
 192         if (pgd_none(READ_ONCE(*pgdp))) {
 193                 pudp = (void *)get_safe_page(GFP_ATOMIC);
 194                 if (!pudp)
 195                         return -ENOMEM;
 196                 pgd_populate(&init_mm, pgdp, pudp);
 197         }
 198
 199         pudp = pud_offset(pgdp, dst_addr);
 200         if (pud_none(READ_ONCE(*pudp))) {
 201                 pmdp = (void *)get_safe_page(GFP_ATOMIC);
 202                 if (!pmdp)
 203                         return -ENOMEM;
 204                 pud_populate(&init_mm, pudp, pmdp);
 205         }
 206
 207         pmdp = pmd_offset(pudp, dst_addr);
 208         if (pmd_none(READ_ONCE(*pmdp))) {
 209                 ptep = (void *)get_safe_page(GFP_ATOMIC);
 210                 if (!ptep)
 211                         return -ENOMEM;
 212                 pmd_populate_kernel(&init_mm, pmdp, ptep);
 213         }
 214
 215         ptep = pte_offset_kernel(pmdp, dst_addr);
 216         set_pte(ptep, pfn_pte(virt_to_pfn(page), PAGE_KERNEL_EXEC));
 217
 218         return 0;
 219 }
 220
 221 /*
 222  * Copies length bytes, starting at src_start into an new page,
 223  * perform cache maintenance, then maps it at the specified address low
 224  * address as executable.
 225  *
 226  * This is used by hibernate to copy the code it needs to execute when
 227  * overwriting the kernel text. This function generates a new set of page
 228  * tables, which it loads into ttbr0.
 229  *
 230  * Length is provided as we probably only want 4K of data, even on a 64K
 231  * page system.
 232  */
 233 static int create_safe_exec_page(void *src_start, size_t length,
 234                                  unsigned long dst_addr,
 235                                  phys_addr_t *phys_dst_addr)
 236 {
 237         void *page = (void *)get_safe_page(GFP_ATOMIC);
 238         pgd_t *trans_pgd;
 239         int rc;
 240
 241         if (!page)
 242                 return -ENOMEM;
 243
 244         memcpy(page, src_start, length);
 245         __flush_icache_range((unsigned long)page, (unsigned long)page + length);
 246
 247         trans_pgd = (void *)get_safe_page(GFP_ATOMIC);
 248         if (!trans_pgd)
 249                 return -ENOMEM;
 250
 251         rc = trans_pgd_map_page(trans_pgd, page, dst_addr,
 252                                 PAGE_KERNEL_EXEC);
 253         if (rc)
 254                 return rc;
 255
 256         /*
 257          * Load our new page tables. A strict BBM approach requires that we
 258          * ensure that TLBs are free of any entries that may overlap with the
 259          * global mappings we are about to install.
 260          *
 261          * For a real hibernate/resume cycle TTBR0 currently points to a zero
 262          * page, but TLBs may contain stale ASID-tagged entries (e.g. for EFI
 263          * runtime services), while for a userspace-driven test_resume cycle it
 264          * points to userspace page tables (and we must point it at a zero page
 265          * ourselves). Elsewhere we only (un)install the idmap with preemption
 266          * disabled, so T0SZ should be as required regardless.
 267          */
 268         cpu_set_reserved_ttbr0();
 269         local_flush_tlb_all();
 270         write_sysreg(phys_to_ttbr(virt_to_phys(trans_pgd)), ttbr0_el1);
 271         isb();
 272
 273         *phys_dst_addr = virt_to_phys(page);
 274
 275         return 0;
 276 }
 277
 278 #define dcache_clean_range(start, end)  __flush_dcache_area(start, (end - start))
 279
 280 int swsusp_arch_suspend(void)
 281 {
 282         int ret = 0;
 283         unsigned long flags;
 284         struct sleep_stack_data state;
 285
 286         if (cpus_are_stuck_in_kernel()) {
 287                 pr_err("Can't hibernate: no mechanism to offline secondary CPUs.\n");
 288                 return -EBUSY;
 289         }
 290
 291         flags = local_daif_save();
 292
 293         if (__cpu_suspend_enter(&state)) {
 294                 /* make the crash dump kernel image visible/saveable */
 295                 crash_prepare_suspend();
 296
 297                 sleep_cpu = smp_processor_id();
 298                 ret = swsusp_save();
 299         } else {
 300                 /* Clean kernel core startup/idle code to PoC*/
 301                 dcache_clean_range(__mmuoff_data_start, __mmuoff_data_end);
 302                 dcache_clean_range(__idmap_text_start, __idmap_text_end);
 303
 304                 /* Clean kvm setup code to PoC? */
 305                 if (el2_reset_needed()) {
 306                         dcache_clean_range(__hyp_idmap_text_start, __hyp_idmap_text_end);
 307                         dcache_clean_range(__hyp_text_start, __hyp_text_end);
 308                 }
 309
 310                 /* make the crash dump kernel image protected again */
 311                 crash_post_resume();
 312
 313                 /*
 314                  * Tell the hibernation core that we've just restored
 315                  * the memory
 316                  */
 317                 in_suspend = 0;
 318
 319                 sleep_cpu = -EINVAL;
 320                 __cpu_suspend_exit();
 321
 322                 /*
 323                  * Just in case the boot kernel did turn the SSBD
 324                  * mitigation off behind our back, let's set the state
 325                  * to what we expect it to be.
 326                  */
 327                 switch (arm64_get_ssbd_state()) {
 328                 case ARM64_SSBD_FORCE_ENABLE:
 329                 case ARM64_SSBD_KERNEL:
 330                         arm64_set_ssbd_mitigation(true);
 331                 }
 332         }
 333
 334         local_daif_restore(flags);
 335
 336         return ret;
 337 }
 338
 339 static void _copy_pte(pte_t *dst_ptep, pte_t *src_ptep, unsigned long addr)
 340 {
 341         pte_t pte = READ_ONCE(*src_ptep);
 342
 343         if (pte_valid(pte)) {
 344                 /*
 345                  * Resume will overwrite areas that may be marked
 346                  * read only (code, rodata). Clear the RDONLY bit from
 347                  * the temporary mappings we use during restore.
 348                  */
 349                 set_pte(dst_ptep, pte_mkwrite(pte));
 350         } else if (debug_pagealloc_enabled() && !pte_none(pte)) {
 351                 /*
 352                  * debug_pagealloc will removed the PTE_VALID bit if
 353                  * the page isn't in use by the resume kernel. It may have
 354                  * been in use by the original kernel, in which case we need
 355                  * to put it back in our copy to do the restore.
 356                  *
 357                  * Before marking this entry valid, check the pfn should
 358                  * be mapped.
 359                  */
 360                 BUG_ON(!pfn_valid(pte_pfn(pte)));
 361
 362                 set_pte(dst_ptep, pte_mkpresent(pte_mkwrite(pte)));
 363         }
 364 }
 365
 366 static int copy_pte(pmd_t *dst_pmdp, pmd_t *src_pmdp, unsigned long start,
 367                     unsigned long end)
 368 {
 369         pte_t *src_ptep;
 370         pte_t *dst_ptep;
 371         unsigned long addr = start;
 372
 373         dst_ptep = (pte_t *)get_safe_page(GFP_ATOMIC);
 374         if (!dst_ptep)
 375                 return -ENOMEM;
 376         pmd_populate_kernel(&init_mm, dst_pmdp, dst_ptep);
 377         dst_ptep = pte_offset_kernel(dst_pmdp, start);
 378
 379         src_ptep = pte_offset_kernel(src_pmdp, start);
 380         do {
 381                 _copy_pte(dst_ptep, src_ptep, addr);
 382         } while (dst_ptep++, src_ptep++, addr += PAGE_SIZE, addr != end);
 383
 384         return 0;
 385 }
 386
 387 static int copy_pmd(pud_t *dst_pudp, pud_t *src_pudp, unsigned long start,
 388                     unsigned long end)
 389 {
 390         pmd_t *src_pmdp;
 391         pmd_t *dst_pmdp;
 392         unsigned long next;
 393         unsigned long addr = start;
 394
 395         if (pud_none(READ_ONCE(*dst_pudp))) {
 396                 dst_pmdp = (pmd_t *)get_safe_page(GFP_ATOMIC);
 397                 if (!dst_pmdp)
 398                         return -ENOMEM;
 399                 pud_populate(&init_mm, dst_pudp, dst_pmdp);
 400         }
 401         dst_pmdp = pmd_offset(dst_pudp, start);
 402
 403         src_pmdp = pmd_offset(src_pudp, start);
 404         do {
 405                 pmd_t pmd = READ_ONCE(*src_pmdp);
 406
 407                 next = pmd_addr_end(addr, end);
 408                 if (pmd_none(pmd))
 409                         continue;
 410                 if (pmd_table(pmd)) {
 411                         if (copy_pte(dst_pmdp, src_pmdp, addr, next))
 412                                 return -ENOMEM;
 413                 } else {
 414                         set_pmd(dst_pmdp,
 415                                 __pmd(pmd_val(pmd) & ~PMD_SECT_RDONLY));
 416                 }
 417         } while (dst_pmdp++, src_pmdp++, addr = next, addr != end);
 418
 419         return 0;
 420 }
 421
 422 static int copy_pud(pgd_t *dst_pgdp, pgd_t *src_pgdp, unsigned long start,
 423                     unsigned long end)
 424 {
 425         pud_t *dst_pudp;
 426         pud_t *src_pudp;
 427         unsigned long next;
 428         unsigned long addr = start;
 429
 430         if (pgd_none(READ_ONCE(*dst_pgdp))) {
 431                 dst_pudp = (pud_t *)get_safe_page(GFP_ATOMIC);
 432                 if (!dst_pudp)
 433                         return -ENOMEM;
 434                 pgd_populate(&init_mm, dst_pgdp, dst_pudp);
 435         }
 436         dst_pudp = pud_offset(dst_pgdp, start);
 437
 438         src_pudp = pud_offset(src_pgdp, start);
 439         do {
 440                 pud_t pud = READ_ONCE(*src_pudp);
 441
 442                 next = pud_addr_end(addr, end);
 443                 if (pud_none(pud))
 444                         continue;
 445                 if (pud_table(pud)) {
 446                         if (copy_pmd(dst_pudp, src_pudp, addr, next))
 447                                 return -ENOMEM;
 448                 } else {
 449                         set_pud(dst_pudp,
 450                                 __pud(pud_val(pud) & ~PUD_SECT_RDONLY));
 451                 }
 452         } while (dst_pudp++, src_pudp++, addr = next, addr != end);
 453
 454         return 0;
 455 }
 456
 457 static int copy_page_tables(pgd_t *dst_pgdp, unsigned long start,
 458                             unsigned long end)
 459 {
 460         unsigned long next;
 461         unsigned long addr = start;
 462         pgd_t *src_pgdp = pgd_offset_k(start);
 463
 464         dst_pgdp = pgd_offset_raw(dst_pgdp, start);
 465         do {
 466                 next = pgd_addr_end(addr, end);
 467                 if (pgd_none(READ_ONCE(*src_pgdp)))
 468                         continue;
 469                 if (copy_pud(dst_pgdp, src_pgdp, addr, next))
 470                         return -ENOMEM;
 471         } while (dst_pgdp++, src_pgdp++, addr = next, addr != end);
 472
 473         return 0;
 474 }
 475
 476 static int trans_pgd_create_copy(pgd_t **dst_pgdp, unsigned long start,
 477                           unsigned long end)
 478 {
 479         int rc;
 480         pgd_t *trans_pgd = (pgd_t *)get_safe_page(GFP_ATOMIC);
 481
 482         if (!trans_pgd) {
 483                 pr_err("Failed to allocate memory for temporary page tables.\n");
 484                 return -ENOMEM;
 485         }
 486
 487         rc = copy_page_tables(trans_pgd, start, end);
 488         if (!rc)
 489                 *dst_pgdp = trans_pgd;
 490
 491         return rc;
 492 }
 493
 494 /*
 495  * Setup then Resume from the hibernate image using swsusp_arch_suspend_exit().
 496  *
 497  * Memory allocated by get_safe_page() will be dealt with by the hibernate code,
 498  * we don't need to free it here.
 499  */
 500 int swsusp_arch_resume(void)
 501 {
 502         int rc;
 503         void *zero_page;
 504         size_t exit_size;
 505         pgd_t *tmp_pg_dir;
 506         phys_addr_t phys_hibernate_exit;
 507         void __noreturn (*hibernate_exit)(phys_addr_t, phys_addr_t, void *,
 508                                           void *, phys_addr_t, phys_addr_t);
 509
 510         /*
 511          * Restoring the memory image will overwrite the ttbr1 page tables.
 512          * Create a second copy of just the linear map, and use this when
 513          * restoring.
 514          */
 515         rc = trans_pgd_create_copy(&tmp_pg_dir, PAGE_OFFSET, PAGE_END);
 516         if (rc)
 517                 return rc;
 518
 519         /*
 520          * We need a zero page that is zero before & after resume in order to
 521          * to break before make on the ttbr1 page tables.
 522          */
 523         zero_page = (void *)get_safe_page(GFP_ATOMIC);
 524         if (!zero_page) {
 525                 pr_err("Failed to allocate zero page.\n");
 526                 return -ENOMEM;
 527         }
 528
 529         /*
 530          * Locate the exit code in the bottom-but-one page, so that *NULL
 531          * still has disastrous affects.
 532          */
 533         hibernate_exit = (void *)PAGE_SIZE;
 534         exit_size = __hibernate_exit_text_end - __hibernate_exit_text_start;
 535         /*
 536          * Copy swsusp_arch_suspend_exit() to a safe page. This will generate
 537          * a new set of ttbr0 page tables and load them.
 538          */
 539         rc = create_safe_exec_page(__hibernate_exit_text_start, exit_size,
 540                                    (unsigned long)hibernate_exit,
 541                                    &phys_hibernate_exit);
 542         if (rc) {
 543                 pr_err("Failed to create safe executable page for hibernate_exit code.\n");
 544                 return rc;
 545         }
 546
 547         /*
 548          * The hibernate exit text contains a set of el2 vectors, that will
 549          * be executed at el2 with the mmu off in order to reload hyp-stub.
 550          */
 551         __flush_dcache_area(hibernate_exit, exit_size);
 552
 553         /*
 554          * KASLR will cause the el2 vectors to be in a different location in
 555          * the resumed kernel. Load hibernate's temporary copy into el2.
 556          *
 557          * We can skip this step if we booted at EL1, or are running with VHE.
 558          */
 559         if (el2_reset_needed()) {
 560                 phys_addr_t el2_vectors = phys_hibernate_exit;  /* base */
 561                 el2_vectors += hibernate_el2_vectors -
 562                                __hibernate_exit_text_start;     /* offset */
 563
 564                 __hyp_set_vectors(el2_vectors);
 565         }
 566
 567         hibernate_exit(virt_to_phys(tmp_pg_dir), resume_hdr.ttbr1_el1,
 568                        resume_hdr.reenter_kernel, restore_pblist,
 569                        resume_hdr.__hyp_stub_vectors, virt_to_phys(zero_page));
 570
 571         return 0;
 572 }
 573
 574 int hibernate_resume_nonboot_cpu_disable(void)
 575 {
 576         if (sleep_cpu < 0) {
 577                 pr_err("Failing to resume from hibernate on an unknown CPU.\n");
 578                 return -ENODEV;
 579         }
 580
 581         return freeze_secondary_cpus(sleep_cpu);
 582 }