arch/s390/kernel/vdso.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * vdso setup for s390
   4  *
   5  *  Copyright IBM Corp. 2008
   6  *  Author(s): Martin Schwidefsky (schwidefsky@de.ibm.com)
   7  */
   8
   9 #include <linux/binfmts.h>
  10 #include <linux/compat.h>
  11 #include <linux/elf.h>
  12 #include <linux/errno.h>
  13 #include <linux/init.h>
  14 #include <linux/kernel.h>
  15 #include <linux/mm.h>
  16 #include <linux/slab.h>
  17 #include <linux/smp.h>
  18 #include <linux/time_namespace.h>
  19 #include <vdso/datapage.h>
  20 #include <asm/vdso.h>
  21
  22 extern char vdso64_start[], vdso64_end[];
  23 static unsigned int vdso_pages;
  24
  25 static struct vm_special_mapping vvar_mapping;
  26
  27 static union {
  28         struct vdso_data        data[CS_BASES];
  29         u8                      page[PAGE_SIZE];
  30 } vdso_data_store __page_aligned_data;
  31
  32 struct vdso_data *vdso_data = vdso_data_store.data;
  33
  34 enum vvar_pages {
  35         VVAR_DATA_PAGE_OFFSET,
  36         VVAR_TIMENS_PAGE_OFFSET,
  37         VVAR_NR_PAGES,
  38 };
  39
  40 unsigned int __read_mostly vdso_enabled = 1;
  41
  42 static int __init vdso_setup(char *str)
  43 {
  44         bool enabled;
  45
  46         if (!kstrtobool(str, &enabled))
  47                 vdso_enabled = enabled;
  48         return 1;
  49 }
  50 __setup("vdso=", vdso_setup);
  51
  52 #ifdef CONFIG_TIME_NS
  53 struct vdso_data *arch_get_vdso_data(void *vvar_page)
  54 {
  55         return (struct vdso_data *)(vvar_page);
  56 }
  57
  58 static struct page *find_timens_vvar_page(struct vm_area_struct *vma)
  59 {
  60         if (likely(vma->vm_mm == current->mm))
  61                 return current->nsproxy->time_ns->vvar_page;
  62         /*
  63          * VM_PFNMAP | VM_IO protect .fault() handler from being called
  64          * through interfaces like /proc/$pid/mem or
  65          * process_vm_{readv,writev}() as long as there's no .access()
  66          * in special_mapping_vmops().
  67          * For more details check_vma_flags() and __access_remote_vm()
  68          */
  69         WARN(1, "vvar_page accessed remotely");
  70         return NULL;
  71 }
  72
  73 /*
  74  * The VVAR page layout depends on whether a task belongs to the root or
  75  * non-root time namespace. Whenever a task changes its namespace, the VVAR
  76  * page tables are cleared and then they will be re-faulted with a
  77  * corresponding layout.
  78  * See also the comment near timens_setup_vdso_data() for details.
  79  */
  80 int vdso_join_timens(struct task_struct *task, struct time_namespace *ns)
  81 {
  82         struct mm_struct *mm = task->mm;
  83         struct vm_area_struct *vma;
  84
  85         mmap_read_lock(mm);
  86         for (vma = mm->mmap; vma; vma = vma->vm_next) {
  87                 unsigned long size = vma->vm_end - vma->vm_start;
  88
  89                 if (!vma_is_special_mapping(vma, &vvar_mapping))
  90                         continue;
  91                 zap_page_range(vma, vma->vm_start, size);
  92                 break;
  93         }
  94         mmap_read_unlock(mm);
  95         return 0;
  96 }
  97 #else
  98 static inline struct page *find_timens_vvar_page(struct vm_area_struct *vma)
  99 {
 100         return NULL;
 101 }
 102 #endif
 103
 104 static vm_fault_t vvar_fault(const struct vm_special_mapping *sm,
 105                              struct vm_area_struct *vma, struct vm_fault *vmf)
 106 {
 107         struct page *timens_page = find_timens_vvar_page(vma);
 108         unsigned long pfn;
 109
 110         switch (vmf->pgoff) {
 111         case VVAR_DATA_PAGE_OFFSET:
 112                 if (timens_page)
 113                         pfn = page_to_pfn(timens_page);
 114                 else
 115                         pfn = virt_to_pfn(vdso_data);
 116                 break;
 117 #ifdef CONFIG_TIME_NS
 118         case VVAR_TIMENS_PAGE_OFFSET:
 119                 /*
 120                  * If a task belongs to a time namespace then a namespace
 121                  * specific VVAR is mapped with the VVAR_DATA_PAGE_OFFSET and
 122                  * the real VVAR page is mapped with the VVAR_TIMENS_PAGE_OFFSET
 123                  * offset.
 124                  * See also the comment near timens_setup_vdso_data().
 125                  */
 126                 if (!timens_page)
 127                         return VM_FAULT_SIGBUS;
 128                 pfn = virt_to_pfn(vdso_data);
 129                 break;
 130 #endif /* CONFIG_TIME_NS */
 131         default:
 132                 return VM_FAULT_SIGBUS;
 133         }
 134         return vmf_insert_pfn(vma, vmf->address, pfn);
 135 }
 136
 137 static int vdso_mremap(const struct vm_special_mapping *sm,
 138                        struct vm_area_struct *vma)
 139 {
 140         current->mm->context.vdso_base = vma->vm_start;
 141         return 0;
 142 }
 143
 144 static struct vm_special_mapping vvar_mapping = {
 145         .name = "[vvar]",
 146         .fault = vvar_fault,
 147 };
 148
 149 static struct vm_special_mapping vdso_mapping = {
 150         .name = "[vdso]",
 151         .mremap = vdso_mremap,
 152 };
 153
 154 int vdso_getcpu_init(void)
 155 {
 156         set_tod_programmable_field(smp_processor_id());
 157         return 0;
 158 }
 159 early_initcall(vdso_getcpu_init); /* Must be called before SMP init */
 160
 161 int arch_setup_additional_pages(struct linux_binprm *bprm, int uses_interp)
 162 {
 163         unsigned long vdso_text_len, vdso_mapping_len;
 164         unsigned long vvar_start, vdso_text_start;
 165         struct mm_struct *mm = current->mm;
 166         struct vm_area_struct *vma;
 167         int rc;
 168
 169         BUILD_BUG_ON(VVAR_NR_PAGES != __VVAR_PAGES);
 170         if (!vdso_enabled || is_compat_task())
 171                 return 0;
 172         if (mmap_write_lock_killable(mm))
 173                 return -EINTR;
 174         vdso_text_len = vdso_pages << PAGE_SHIFT;
 175         vdso_mapping_len = vdso_text_len + VVAR_NR_PAGES * PAGE_SIZE;
 176         vvar_start = get_unmapped_area(NULL, 0, vdso_mapping_len, 0, 0);
 177         rc = vvar_start;
 178         if (IS_ERR_VALUE(vvar_start))
 179                 goto out;
 180         vma = _install_special_mapping(mm, vvar_start, VVAR_NR_PAGES*PAGE_SIZE,
 181                                        VM_READ|VM_MAYREAD|VM_IO|VM_DONTDUMP|
 182                                        VM_PFNMAP,
 183                                        &vvar_mapping);
 184         rc = PTR_ERR(vma);
 185         if (IS_ERR(vma))
 186                 goto out;
 187         vdso_text_start = vvar_start + VVAR_NR_PAGES * PAGE_SIZE;
 188         /* VM_MAYWRITE for COW so gdb can set breakpoints */
 189         vma = _install_special_mapping(mm, vdso_text_start, vdso_text_len,
 190                                        VM_READ|VM_EXEC|
 191                                        VM_MAYREAD|VM_MAYWRITE|VM_MAYEXEC,
 192                                        &vdso_mapping);
 193         if (IS_ERR(vma)) {
 194                 do_munmap(mm, vvar_start, PAGE_SIZE, NULL);
 195                 rc = PTR_ERR(vma);
 196         } else {
 197                 current->mm->context.vdso_base = vdso_text_start;
 198                 rc = 0;
 199         }
 200 out:
 201         mmap_write_unlock(mm);
 202         return rc;
 203 }
 204
 205 static int __init vdso_init(void)
 206 {
 207         struct page **pages;
 208         int i;
 209
 210         vdso_pages = (vdso64_end - vdso64_start) >> PAGE_SHIFT;
 211         pages = kcalloc(vdso_pages + 1, sizeof(struct page *), GFP_KERNEL);
 212         if (!pages) {
 213                 vdso_enabled = 0;
 214                 return -ENOMEM;
 215         }
 216         for (i = 0; i < vdso_pages; i++)
 217                 pages[i] = virt_to_page(vdso64_start + i * PAGE_SIZE);
 218         pages[vdso_pages] = NULL;
 219         vdso_mapping.pages = pages;
 220         return 0;
 221 }
 222 arch_initcall(vdso_init);