~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/arm64/kernel/vdso.c

Version: ~ [ linux-5.11-rc3 ] ~ [ linux-5.10.7 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.89 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.167 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.215 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.251 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.251 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * VDSO implementation for AArch64 and vector page setup for AArch32.
  3  *
  4  * Copyright (C) 2012 ARM Limited
  5  *
  6  * This program is free software; you can redistribute it and/or modify
  7  * it under the terms of the GNU General Public License version 2 as
  8  * published by the Free Software Foundation.
  9  *
 10  * This program is distributed in the hope that it will be useful,
 11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 13  * GNU General Public License for more details.
 14  *
 15  * You should have received a copy of the GNU General Public License
 16  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 17  *
 18  * Author: Will Deacon <will.deacon@arm.com>
 19  */
 20 
 21 #include <linux/kernel.h>
 22 #include <linux/clocksource.h>
 23 #include <linux/elf.h>
 24 #include <linux/err.h>
 25 #include <linux/errno.h>
 26 #include <linux/gfp.h>
 27 #include <linux/mm.h>
 28 #include <linux/sched.h>
 29 #include <linux/signal.h>
 30 #include <linux/slab.h>
 31 #include <linux/timekeeper_internal.h>
 32 #include <linux/vmalloc.h>
 33 
 34 #include <asm/cacheflush.h>
 35 #include <asm/signal32.h>
 36 #include <asm/vdso.h>
 37 #include <asm/vdso_datapage.h>
 38 
 39 extern char vdso_start, vdso_end;
 40 static unsigned long vdso_pages;
 41 static struct page **vdso_pagelist;
 42 
 43 /*
 44  * The vDSO data page.
 45  */
 46 static union {
 47         struct vdso_data        data;
 48         u8                      page[PAGE_SIZE];
 49 } vdso_data_store __page_aligned_data;
 50 struct vdso_data *vdso_data = &vdso_data_store.data;
 51 
 52 #ifdef CONFIG_COMPAT
 53 /*
 54  * Create and map the vectors page for AArch32 tasks.
 55  */
 56 static struct page *vectors_page[1];
 57 
 58 static int alloc_vectors_page(void)
 59 {
 60         extern char __kuser_helper_start[], __kuser_helper_end[];
 61         extern char __aarch32_sigret_code_start[], __aarch32_sigret_code_end[];
 62 
 63         int kuser_sz = __kuser_helper_end - __kuser_helper_start;
 64         int sigret_sz = __aarch32_sigret_code_end - __aarch32_sigret_code_start;
 65         unsigned long vpage;
 66 
 67         vpage = get_zeroed_page(GFP_ATOMIC);
 68 
 69         if (!vpage)
 70                 return -ENOMEM;
 71 
 72         /* kuser helpers */
 73         memcpy((void *)vpage + 0x1000 - kuser_sz, __kuser_helper_start,
 74                 kuser_sz);
 75 
 76         /* sigreturn code */
 77         memcpy((void *)vpage + AARCH32_KERN_SIGRET_CODE_OFFSET,
 78                __aarch32_sigret_code_start, sigret_sz);
 79 
 80         flush_icache_range(vpage, vpage + PAGE_SIZE);
 81         vectors_page[0] = virt_to_page(vpage);
 82 
 83         return 0;
 84 }
 85 arch_initcall(alloc_vectors_page);
 86 
 87 int aarch32_setup_vectors_page(struct linux_binprm *bprm, int uses_interp)
 88 {
 89         struct mm_struct *mm = current->mm;
 90         unsigned long addr = AARCH32_VECTORS_BASE;
 91         static struct vm_special_mapping spec = {
 92                 .name   = "[vectors]",
 93                 .pages  = vectors_page,
 94 
 95         };
 96         void *ret;
 97 
 98         if (down_write_killable(&mm->mmap_sem))
 99                 return -EINTR;
100         current->mm->context.vdso = (void *)addr;
101 
102         /* Map vectors page at the high address. */
103         ret = _install_special_mapping(mm, addr, PAGE_SIZE,
104                                        VM_READ|VM_EXEC|VM_MAYREAD|VM_MAYEXEC,
105                                        &spec);
106 
107         up_write(&mm->mmap_sem);
108 
109         return PTR_ERR_OR_ZERO(ret);
110 }
111 #endif /* CONFIG_COMPAT */
112 
113 static struct vm_special_mapping vdso_spec[2];
114 
115 static int __init vdso_init(void)
116 {
117         int i;
118 
119         if (memcmp(&vdso_start, "\177ELF", 4)) {
120                 pr_err("vDSO is not a valid ELF object!\n");
121                 return -EINVAL;
122         }
123 
124         vdso_pages = (&vdso_end - &vdso_start) >> PAGE_SHIFT;
125         pr_info("vdso: %ld pages (%ld code @ %p, %ld data @ %p)\n",
126                 vdso_pages + 1, vdso_pages, &vdso_start, 1L, vdso_data);
127 
128         /* Allocate the vDSO pagelist, plus a page for the data. */
129         vdso_pagelist = kcalloc(vdso_pages + 1, sizeof(struct page *),
130                                 GFP_KERNEL);
131         if (vdso_pagelist == NULL)
132                 return -ENOMEM;
133 
134         /* Grab the vDSO data page. */
135         vdso_pagelist[0] = pfn_to_page(PHYS_PFN(__pa(vdso_data)));
136 
137         /* Grab the vDSO code pages. */
138         for (i = 0; i < vdso_pages; i++)
139                 vdso_pagelist[i + 1] = pfn_to_page(PHYS_PFN(__pa(&vdso_start)) + i);
140 
141         /* Populate the special mapping structures */
142         vdso_spec[0] = (struct vm_special_mapping) {
143                 .name   = "[vvar]",
144                 .pages  = vdso_pagelist,
145         };
146 
147         vdso_spec[1] = (struct vm_special_mapping) {
148                 .name   = "[vdso]",
149                 .pages  = &vdso_pagelist[1],
150         };
151 
152         return 0;
153 }
154 arch_initcall(vdso_init);
155 
156 int arch_setup_additional_pages(struct linux_binprm *bprm,
157                                 int uses_interp)
158 {
159         struct mm_struct *mm = current->mm;
160         unsigned long vdso_base, vdso_text_len, vdso_mapping_len;
161         void *ret;
162 
163         vdso_text_len = vdso_pages << PAGE_SHIFT;
164         /* Be sure to map the data page */
165         vdso_mapping_len = vdso_text_len + PAGE_SIZE;
166 
167         if (down_write_killable(&mm->mmap_sem))
168                 return -EINTR;
169         vdso_base = get_unmapped_area(NULL, 0, vdso_mapping_len, 0, 0);
170         if (IS_ERR_VALUE(vdso_base)) {
171                 ret = ERR_PTR(vdso_base);
172                 goto up_fail;
173         }
174         ret = _install_special_mapping(mm, vdso_base, PAGE_SIZE,
175                                        VM_READ|VM_MAYREAD,
176                                        &vdso_spec[0]);
177         if (IS_ERR(ret))
178                 goto up_fail;
179 
180         vdso_base += PAGE_SIZE;
181         mm->context.vdso = (void *)vdso_base;
182         ret = _install_special_mapping(mm, vdso_base, vdso_text_len,
183                                        VM_READ|VM_EXEC|
184                                        VM_MAYREAD|VM_MAYWRITE|VM_MAYEXEC,
185                                        &vdso_spec[1]);
186         if (IS_ERR(ret))
187                 goto up_fail;
188 
189 
190         up_write(&mm->mmap_sem);
191         return 0;
192 
193 up_fail:
194         mm->context.vdso = NULL;
195         up_write(&mm->mmap_sem);
196         return PTR_ERR(ret);
197 }
198 
199 /*
200  * Update the vDSO data page to keep in sync with kernel timekeeping.
201  */
202 void update_vsyscall(struct timekeeper *tk)
203 {
204         u32 use_syscall = strcmp(tk->tkr_mono.clock->name, "arch_sys_counter");
205 
206         ++vdso_data->tb_seq_count;
207         smp_wmb();
208 
209         vdso_data->use_syscall                  = use_syscall;
210         vdso_data->xtime_coarse_sec             = tk->xtime_sec;
211         vdso_data->xtime_coarse_nsec            = tk->tkr_mono.xtime_nsec >>
212                                                         tk->tkr_mono.shift;
213         vdso_data->wtm_clock_sec                = tk->wall_to_monotonic.tv_sec;
214         vdso_data->wtm_clock_nsec               = tk->wall_to_monotonic.tv_nsec;
215 
216         if (!use_syscall) {
217                 /* tkr_mono.cycle_last == tkr_raw.cycle_last */
218                 vdso_data->cs_cycle_last        = tk->tkr_mono.cycle_last;
219                 vdso_data->raw_time_sec         = tk->raw_time.tv_sec;
220                 vdso_data->raw_time_nsec        = tk->raw_time.tv_nsec;
221                 vdso_data->xtime_clock_sec      = tk->xtime_sec;
222                 vdso_data->xtime_clock_nsec     = tk->tkr_mono.xtime_nsec;
223                 /* tkr_raw.xtime_nsec == 0 */
224                 vdso_data->cs_mono_mult         = tk->tkr_mono.mult;
225                 vdso_data->cs_raw_mult          = tk->tkr_raw.mult;
226                 /* tkr_mono.shift == tkr_raw.shift */
227                 vdso_data->cs_shift             = tk->tkr_mono.shift;
228         }
229 
230         smp_wmb();
231         ++vdso_data->tb_seq_count;
232 }
233 
234 void update_vsyscall_tz(void)
235 {
236         vdso_data->tz_minuteswest       = sys_tz.tz_minuteswest;
237         vdso_data->tz_dsttime           = sys_tz.tz_dsttime;
238 }
239 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp