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

TOMOYO Linux Cross Reference
Linux/arch/s390/kernel/machine_kexec_file.c

Version: ~ [ linux-4.18-rc1 ] ~ [ linux-4.17.2 ] ~ [ linux-4.16.16 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.50 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.109 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.138 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.113 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.57 ] ~ [ 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-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.27.62 ] ~ [ 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 // SPDX-License-Identifier: GPL-2.0
  2 /*
  3  * s390 code for kexec_file_load system call
  4  *
  5  * Copyright IBM Corp. 2018
  6  *
  7  * Author(s): Philipp Rudo <prudo@linux.vnet.ibm.com>
  8  */
  9 
 10 #include <linux/elf.h>
 11 #include <linux/kexec.h>
 12 #include <asm/setup.h>
 13 
 14 const struct kexec_file_ops * const kexec_file_loaders[] = {
 15         &s390_kexec_elf_ops,
 16         &s390_kexec_image_ops,
 17         NULL,
 18 };
 19 
 20 int *kexec_file_update_kernel(struct kimage *image,
 21                               struct s390_load_data *data)
 22 {
 23         unsigned long *loc;
 24 
 25         if (image->cmdline_buf_len >= ARCH_COMMAND_LINE_SIZE)
 26                 return ERR_PTR(-EINVAL);
 27 
 28         if (image->cmdline_buf_len)
 29                 memcpy(data->kernel_buf + COMMAND_LINE_OFFSET,
 30                        image->cmdline_buf, image->cmdline_buf_len);
 31 
 32         if (image->type == KEXEC_TYPE_CRASH) {
 33                 loc = (unsigned long *)(data->kernel_buf + OLDMEM_BASE_OFFSET);
 34                 *loc = crashk_res.start;
 35 
 36                 loc = (unsigned long *)(data->kernel_buf + OLDMEM_SIZE_OFFSET);
 37                 *loc = crashk_res.end - crashk_res.start + 1;
 38         }
 39 
 40         if (image->initrd_buf) {
 41                 loc = (unsigned long *)(data->kernel_buf + INITRD_START_OFFSET);
 42                 *loc = data->initrd_load_addr;
 43 
 44                 loc = (unsigned long *)(data->kernel_buf + INITRD_SIZE_OFFSET);
 45                 *loc = image->initrd_buf_len;
 46         }
 47 
 48         return NULL;
 49 }
 50 
 51 static int kexec_file_update_purgatory(struct kimage *image)
 52 {
 53         u64 entry, type;
 54         int ret;
 55 
 56         if (image->type == KEXEC_TYPE_CRASH) {
 57                 entry = STARTUP_KDUMP_OFFSET;
 58                 type = KEXEC_TYPE_CRASH;
 59         } else {
 60                 entry = STARTUP_NORMAL_OFFSET;
 61                 type = KEXEC_TYPE_DEFAULT;
 62         }
 63 
 64         ret = kexec_purgatory_get_set_symbol(image, "kernel_entry", &entry,
 65                                              sizeof(entry), false);
 66         if (ret)
 67                 return ret;
 68 
 69         ret = kexec_purgatory_get_set_symbol(image, "kernel_type", &type,
 70                                              sizeof(type), false);
 71         if (ret)
 72                 return ret;
 73 
 74         if (image->type == KEXEC_TYPE_CRASH) {
 75                 u64 crash_size;
 76 
 77                 ret = kexec_purgatory_get_set_symbol(image, "crash_start",
 78                                                      &crashk_res.start,
 79                                                      sizeof(crashk_res.start),
 80                                                      false);
 81                 if (ret)
 82                         return ret;
 83 
 84                 crash_size = crashk_res.end - crashk_res.start + 1;
 85                 ret = kexec_purgatory_get_set_symbol(image, "crash_size",
 86                                                      &crash_size,
 87                                                      sizeof(crash_size),
 88                                                      false);
 89         }
 90         return ret;
 91 }
 92 
 93 int kexec_file_add_purgatory(struct kimage *image, struct s390_load_data *data)
 94 {
 95         struct kexec_buf buf;
 96         int ret;
 97 
 98         buf.image = image;
 99 
100         data->memsz = ALIGN(data->memsz, PAGE_SIZE);
101         buf.mem = data->memsz;
102         if (image->type == KEXEC_TYPE_CRASH)
103                 buf.mem += crashk_res.start;
104 
105         ret = kexec_load_purgatory(image, &buf);
106         if (ret)
107                 return ret;
108 
109         ret = kexec_file_update_purgatory(image);
110         return ret;
111 }
112 
113 int kexec_file_add_initrd(struct kimage *image, struct s390_load_data *data,
114                           char *initrd, unsigned long initrd_len)
115 {
116         struct kexec_buf buf;
117         int ret;
118 
119         buf.image = image;
120 
121         buf.buffer = initrd;
122         buf.bufsz = initrd_len;
123 
124         data->memsz = ALIGN(data->memsz, PAGE_SIZE);
125         buf.mem = data->memsz;
126         if (image->type == KEXEC_TYPE_CRASH)
127                 buf.mem += crashk_res.start;
128         buf.memsz = buf.bufsz;
129 
130         data->initrd_load_addr = buf.mem;
131         data->memsz += buf.memsz;
132 
133         ret = kexec_add_buffer(&buf);
134         return ret;
135 }
136 
137 /*
138  * The kernel is loaded to a fixed location. Turn off kexec_locate_mem_hole
139  * and provide kbuf->mem by hand.
140  */
141 int arch_kexec_walk_mem(struct kexec_buf *kbuf,
142                         int (*func)(struct resource *, void *))
143 {
144         return 1;
145 }
146 
147 int arch_kexec_apply_relocations_add(struct purgatory_info *pi,
148                                      Elf_Shdr *section,
149                                      const Elf_Shdr *relsec,
150                                      const Elf_Shdr *symtab)
151 {
152         Elf_Rela *relas;
153         int i;
154 
155         relas = (void *)pi->ehdr + relsec->sh_offset;
156 
157         for (i = 0; i < relsec->sh_size / sizeof(*relas); i++) {
158                 const Elf_Sym *sym;     /* symbol to relocate */
159                 unsigned long addr;     /* final location after relocation */
160                 unsigned long val;      /* relocated symbol value */
161                 void *loc;              /* tmp location to modify */
162 
163                 sym = (void *)pi->ehdr + symtab->sh_offset;
164                 sym += ELF64_R_SYM(relas[i].r_info);
165 
166                 if (sym->st_shndx == SHN_UNDEF)
167                         return -ENOEXEC;
168 
169                 if (sym->st_shndx == SHN_COMMON)
170                         return -ENOEXEC;
171 
172                 if (sym->st_shndx >= pi->ehdr->e_shnum &&
173                     sym->st_shndx != SHN_ABS)
174                         return -ENOEXEC;
175 
176                 loc = pi->purgatory_buf;
177                 loc += section->sh_offset;
178                 loc += relas[i].r_offset;
179 
180                 val = sym->st_value;
181                 if (sym->st_shndx != SHN_ABS)
182                         val += pi->sechdrs[sym->st_shndx].sh_addr;
183                 val += relas[i].r_addend;
184 
185                 addr = section->sh_addr + relas[i].r_offset;
186 
187                 switch (ELF64_R_TYPE(relas[i].r_info)) {
188                 case R_390_8:           /* Direct 8 bit.   */
189                         *(u8 *)loc = val;
190                         break;
191                 case R_390_12:          /* Direct 12 bit.  */
192                         *(u16 *)loc &= 0xf000;
193                         *(u16 *)loc |= val & 0xfff;
194                         break;
195                 case R_390_16:          /* Direct 16 bit.  */
196                         *(u16 *)loc = val;
197                         break;
198                 case R_390_20:          /* Direct 20 bit.  */
199                         *(u32 *)loc &= 0xf00000ff;
200                         *(u32 *)loc |= (val & 0xfff) << 16;     /* DL */
201                         *(u32 *)loc |= (val & 0xff000) >> 4;    /* DH */
202                         break;
203                 case R_390_32:          /* Direct 32 bit.  */
204                         *(u32 *)loc = val;
205                         break;
206                 case R_390_64:          /* Direct 64 bit.  */
207                         *(u64 *)loc = val;
208                         break;
209                 case R_390_PC16:        /* PC relative 16 bit.  */
210                         *(u16 *)loc = (val - addr);
211                         break;
212                 case R_390_PC16DBL:     /* PC relative 16 bit shifted by 1.  */
213                         *(u16 *)loc = (val - addr) >> 1;
214                         break;
215                 case R_390_PC32DBL:     /* PC relative 32 bit shifted by 1.  */
216                         *(u32 *)loc = (val - addr) >> 1;
217                         break;
218                 case R_390_PC32:        /* PC relative 32 bit.  */
219                         *(u32 *)loc = (val - addr);
220                         break;
221                 case R_390_PC64:        /* PC relative 64 bit.  */
222                         *(u64 *)loc = (val - addr);
223                         break;
224                 default:
225                         break;
226                 }
227         }
228         return 0;
229 }
230 
231 int arch_kexec_kernel_image_probe(struct kimage *image, void *buf,
232                                   unsigned long buf_len)
233 {
234         /* A kernel must be at least large enough to contain head.S. During
235          * load memory in head.S will be accessed, e.g. to register the next
236          * command line. If the next kernel were smaller the current kernel
237          * will panic at load.
238          *
239          * 0x11000 = sizeof(head.S)
240          */
241         if (buf_len < 0x11000)
242                 return -ENOEXEC;
243 
244         return kexec_image_probe_default(image, buf, buf_len);
245 }
246 

~ [ 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