1 /*
2 * kexec.c - kexec system call
3 * Copyright (C) 2002-2004 Eric Biederman <ebiederm@xmission.com>
4 *
5 * This source code is licensed under the GNU General Public License,
6 * Version 2. See the file COPYING for more details.
7 */
8
9 #include <linux/capability.h>
10 #include <linux/mm.h>
11 #include <linux/file.h>
12 #include <linux/slab.h>
13 #include <linux/fs.h>
14 #include <linux/kexec.h>
15 #include <linux/spinlock.h>
16 #include <linux/list.h>
17 #include <linux/highmem.h>
18 #include <linux/syscalls.h>
19 #include <linux/reboot.h>
20 #include <linux/syscalls.h>
21 #include <linux/ioport.h>
22 #include <linux/hardirq.h>
23
24 #include <asm/page.h>
25 #include <asm/uaccess.h>
26 #include <asm/io.h>
27 #include <asm/system.h>
28 #include <asm/semaphore.h>
29
30 /* Per cpu memory for storing cpu states in case of system crash. */
31 note_buf_t* crash_notes;
32
33 /* Location of the reserved area for the crash kernel */
34 struct resource crashk_res = {
35 .name = "Crash kernel",
36 .start = 0,
37 .end = 0,
38 .flags = IORESOURCE_BUSY | IORESOURCE_MEM
39 };
40
41 int kexec_should_crash(struct task_struct *p)
42 {
43 if (in_interrupt() || !p->pid || p->pid == 1 || panic_on_oops)
44 return 1;
45 return 0;
46 }
47
48 /*
49 * When kexec transitions to the new kernel there is a one-to-one
50 * mapping between physical and virtual addresses. On processors
51 * where you can disable the MMU this is trivial, and easy. For
52 * others it is still a simple predictable page table to setup.
53 *
54 * In that environment kexec copies the new kernel to its final
55 * resting place. This means I can only support memory whose
56 * physical address can fit in an unsigned long. In particular
57 * addresses where (pfn << PAGE_SHIFT) > ULONG_MAX cannot be handled.
58 * If the assembly stub has more restrictive requirements
59 * KEXEC_SOURCE_MEMORY_LIMIT and KEXEC_DEST_MEMORY_LIMIT can be
60 * defined more restrictively in <asm/kexec.h>.
61 *
62 * The code for the transition from the current kernel to the
63 * the new kernel is placed in the control_code_buffer, whose size
64 * is given by KEXEC_CONTROL_CODE_SIZE. In the best case only a single
65 * page of memory is necessary, but some architectures require more.
66 * Because this memory must be identity mapped in the transition from
67 * virtual to physical addresses it must live in the range
68 * 0 - TASK_SIZE, as only the user space mappings are arbitrarily
69 * modifiable.
70 *
71 * The assembly stub in the control code buffer is passed a linked list
72 * of descriptor pages detailing the source pages of the new kernel,
73 * and the destination addresses of those source pages. As this data
74 * structure is not used in the context of the current OS, it must
75 * be self-contained.
76 *
77 * The code has been made to work with highmem pages and will use a
78 * destination page in its final resting place (if it happens
79 * to allocate it). The end product of this is that most of the
80 * physical address space, and most of RAM can be used.
81 *
82 * Future directions include:
83 * - allocating a page table with the control code buffer identity
84 * mapped, to simplify machine_kexec and make kexec_on_panic more
85 * reliable.
86 */
87
88 /*
89 * KIMAGE_NO_DEST is an impossible destination address..., for
90 * allocating pages whose destination address we do not care about.
91 */
92 #define KIMAGE_NO_DEST (-1UL)
93
94 static int kimage_is_destination_range(struct kimage *image,
95 unsigned long start, unsigned long end);
96 static struct page *kimage_alloc_page(struct kimage *image,
97 gfp_t gfp_mask,
98 unsigned long dest);
99
100 static int do_kimage_alloc(struct kimage **rimage, unsigned long entry,
101 unsigned long nr_segments,
102 struct kexec_segment __user *segments)
103 {
104 size_t segment_bytes;
105 struct kimage *image;
106 unsigned long i;
107 int result;
108
109 /* Allocate a controlling structure */
110 result = -ENOMEM;
111 image = kmalloc(sizeof(*image), GFP_KERNEL);
112 if (!image)
113 goto out;
114
115 memset(image, 0, sizeof(*image));
116 image->head = 0;
117 image->entry = &image->head;
118 image->last_entry = &image->head;
119 image->control_page = ~0; /* By default this does not apply */
120 image->start = entry;
121 image->type = KEXEC_TYPE_DEFAULT;
122
123 /* Initialize the list of control pages */
124 INIT_LIST_HEAD(&image->control_pages);
125
126 /* Initialize the list of destination pages */
127 INIT_LIST_HEAD(&image->dest_pages);
128
129 /* Initialize the list of unuseable pages */
130 INIT_LIST_HEAD(&image->unuseable_pages);
131
132 /* Read in the segments */
133 image->nr_segments = nr_segments;
134 segment_bytes = nr_segments * sizeof(*segments);
135 result = copy_from_user(image->segment, segments, segment_bytes);
136 if (result)
137 goto out;
138
139 /*
140 * Verify we have good destination addresses. The caller is
141 * responsible for making certain we don't attempt to load
142 * the new image into invalid or reserved areas of RAM. This
143 * just verifies it is an address we can use.
144 *
145 * Since the kernel does everything in page size chunks ensure
146 * the destination addreses are page aligned. Too many
147 * special cases crop of when we don't do this. The most
148 * insidious is getting overlapping destination addresses
149 * simply because addresses are changed to page size
150 * granularity.
151 */
152 result = -EADDRNOTAVAIL;
153 for (i = 0; i < nr_segments; i++) {
154 unsigned long mstart, mend;
155
156 mstart = image->segment[i].mem;
157 mend = mstart + image->segment[i].memsz;
158 if ((mstart & ~PAGE_MASK) || (mend & ~PAGE_MASK))
159 goto out;
160 if (mend >= KEXEC_DESTINATION_MEMORY_LIMIT)
161 goto out;
162 }
163
164 /* Verify our destination addresses do not overlap.
165 * If we alloed overlapping destination addresses
166 * through very weird things can happen with no
167 * easy explanation as one segment stops on another.
168 */
169 result = -EINVAL;
170 for (i = 0; i < nr_segments; i++) {
171 unsigned long mstart, mend;
172 unsigned long j;
173
174 mstart = image->segment[i].mem;
175 mend = mstart + image->segment[i].memsz;
176 for (j = 0; j < i; j++) {
177 unsigned long pstart, pend;
178 pstart = image->segment[j].mem;
179 pend = pstart + image->segment[j].memsz;
180 /* Do the segments overlap ? */
181 if ((mend > pstart) && (mstart < pend))
182 goto out;
183 }
184 }
185
186 /* Ensure our buffer sizes are strictly less than
187 * our memory sizes. This should always be the case,
188 * and it is easier to check up front than to be surprised
189 * later on.
190 */
191 result = -EINVAL;
192 for (i = 0; i < nr_segments; i++) {
193 if (image->segment[i].bufsz > image->segment[i].memsz)
194 goto out;
195 }
196
197 result = 0;
198 out:
199 if (result == 0)
200 *rimage = image;
201 else
202 kfree(image);
203
204 return result;
205
206 }
207
208 static int kimage_normal_alloc(struct kimage **rimage, unsigned long entry,
209 unsigned long nr_segments,
210 struct kexec_segment __user *segments)
211 {
212 int result;
213 struct kimage *image;
214
215 /* Allocate and initialize a controlling structure */
216 image = NULL;
217 result = do_kimage_alloc(&image, entry, nr_segments, segments);
218 if (result)
219 goto out;
220
221 *rimage = image;
222
223 /*
224 * Find a location for the control code buffer, and add it
225 * the vector of segments so that it's pages will also be
226 * counted as destination pages.
227 */
228 result = -ENOMEM;
229 image->control_code_page = kimage_alloc_control_pages(image,
230 get_order(KEXEC_CONTROL_CODE_SIZE));
231 if (!image->control_code_page) {
232 printk(KERN_ERR "Could not allocate control_code_buffer\n");
233 goto out;
234 }
235
236 result = 0;
237 out:
238 if (result == 0)
239 *rimage = image;
240 else
241 kfree(image);
242
243 return result;
244 }
245
246 static int kimage_crash_alloc(struct kimage **rimage, unsigned long entry,
247 unsigned long nr_segments,
248 struct kexec_segment __user *segments)
249 {
250 int result;
251 struct kimage *image;
252 unsigned long i;
253
254 image = NULL;
255 /* Verify we have a valid entry point */
256 if ((entry < crashk_res.start) || (entry > crashk_res.end)) {
257 result = -EADDRNOTAVAIL;
258 goto out;
259 }
260
261 /* Allocate and initialize a controlling structure */
262 result = do_kimage_alloc(&image, entry, nr_segments, segments);
263 if (result)
264 goto out;
265
266 /* Enable the special crash kernel control page
267 * allocation policy.
268 */
269 image->control_page = crashk_res.start;
270 image->type = KEXEC_TYPE_CRASH;
271
272 /*
273 * Verify we have good destination addresses. Normally
274 * the caller is responsible for making certain we don't
275 * attempt to load the new image into invalid or reserved
276 * areas of RAM. But crash kernels are preloaded into a
277 * reserved area of ram. We must ensure the addresses
278 * are in the reserved area otherwise preloading the
279 * kernel could corrupt things.
280 */
281 result = -EADDRNOTAVAIL;
282 for (i = 0; i < nr_segments; i++) {
283 unsigned long mstart, mend;
284
285 mstart = image->segment[i].mem;
286 mend = mstart + image->segment[i].memsz - 1;
287 /* Ensure we are within the crash kernel limits */
288 if ((mstart < crashk_res.start) || (mend > crashk_res.end))
289 goto out;
290 }
291
292 /*
293 * Find a location for the control code buffer, and add
294 * the vector of segments so that it's pages will also be
295 * counted as destination pages.
296 */
297 result = -ENOMEM;
298 image->control_code_page = kimage_alloc_control_pages(image,
299 get_order(KEXEC_CONTROL_CODE_SIZE));
300 if (!image->control_code_page) {
301 printk(KERN_ERR "Could not allocate control_code_buffer\n");
302 goto out;
303 }
304
305 result = 0;
306 out:
307 if (result == 0)
308 *rimage = image;
309 else
310 kfree(image);
311
312 return result;
313 }
314
315 static int kimage_is_destination_range(struct kimage *image,
316 unsigned long start,
317 unsigned long end)
318 {
319 unsigned long i;
320
321 for (i = 0; i < image->nr_segments; i++) {
322 unsigned long mstart, mend;
323
324 mstart = image->segment[i].mem;
325 mend = mstart + image->segment[i].memsz;
326 if ((end > mstart) && (start < mend))
327 return 1;
328 }
329
330 return 0;
331 }
332
333 static struct page *kimage_alloc_pages(gfp_t gfp_mask, unsigned int order)
334 {
335 struct page *pages;
336
337 pages = alloc_pages(gfp_mask, order);
338 if (pages) {
339 unsigned int count, i;
340 pages->mapping = NULL;
341 set_page_private(pages, order);
342 count = 1 << order;
343 for (i = 0; i < count; i++)
344 SetPageReserved(pages + i);
345 }
346
347 return pages;
348 }
349
350 static void kimage_free_pages(struct page *page)
351 {
352 unsigned int order, count, i;
353
354 order = page_private(page);
355 count = 1 << order;
356 for (i = 0; i < count; i++)
357 ClearPageReserved(page + i);
358 __free_pages(page, order);
359 }
360
361 static void kimage_free_page_list(struct list_head *list)
362 {
363 struct list_head *pos, *next;
364
365 list_for_each_safe(pos, next, list) {
366 struct page *page;
367
368 page = list_entry(pos, struct page, lru);
369 list_del(&page->lru);
370 kimage_free_pages(page);
371 }
372 }
373
374 static struct page *kimage_alloc_normal_control_pages(struct kimage *image,
375 unsigned int order)
376 {
377 /* Control pages are special, they are the intermediaries
378 * that are needed while we copy the rest of the pages
379 * to their final resting place. As such they must
380 * not conflict with either the destination addresses
381 * or memory the kernel is already using.
382 *
383 * The only case where we really need more than one of
384 * these are for architectures where we cannot disable
385 * the MMU and must instead generate an identity mapped
386 * page table for all of the memory.
387 *
388 * At worst this runs in O(N) of the image size.
389 */
390 struct list_head extra_pages;
391 struct page *pages;
392 unsigned int count;
393
394 count = 1 << order;
395 INIT_LIST_HEAD(&extra_pages);
396
397 /* Loop while I can allocate a page and the page allocated
398 * is a destination page.
399 */
400 do {
401 unsigned long pfn, epfn, addr, eaddr;
402
403 pages = kimage_alloc_pages(GFP_KERNEL, order);
404 if (!pages)
405 break;
406 pfn = page_to_pfn(pages);
407 epfn = pfn + count;
408 addr = pfn << PAGE_SHIFT;
409 eaddr = epfn << PAGE_SHIFT;
410 if ((epfn >= (KEXEC_CONTROL_MEMORY_LIMIT >> PAGE_SHIFT)) ||
411 kimage_is_destination_range(image, addr, eaddr)) {
412 list_add(&pages->lru, &extra_pages);
413 pages = NULL;
414 }
415 } while (!pages);
416
417 if (pages) {
418 /* Remember the allocated page... */
419 list_add(&pages->lru, &image->control_pages);
420
421 /* Because the page is already in it's destination
422 * location we will never allocate another page at
423 * that address. Therefore kimage_alloc_pages
424 * will not return it (again) and we don't need
425 * to give it an entry in image->segment[].
426 */
427 }
428 /* Deal with the destination pages I have inadvertently allocated.
429 *
430 * Ideally I would convert multi-page allocations into single
431 * page allocations, and add everyting to image->dest_pages.
432 *
433 * For now it is simpler to just free the pages.
434 */
435 kimage_free_page_list(&extra_pages);
436
437 return pages;
438 }
439
440 static struct page *kimage_alloc_crash_control_pages(struct kimage *image,
441 unsigned int order)
442 {
443 /* Control pages are special, they are the intermediaries
444 * that are needed while we copy the rest of the pages
445 * to their final resting place. As such they must
446 * not conflict with either the destination addresses
447 * or memory the kernel is already using.
448 *
449 * Control pages are also the only pags we must allocate
450 * when loading a crash kernel. All of the other pages
451 * are specified by the segments and we just memcpy
452 * into them directly.
453 *
454 * The only case where we really need more than one of
455 * these are for architectures where we cannot disable
456 * the MMU and must instead generate an identity mapped
457 * page table for all of the memory.
458 *
459 * Given the low demand this implements a very simple
460 * allocator that finds the first hole of the appropriate
461 * size in the reserved memory region, and allocates all
462 * of the memory up to and including the hole.
463 */
464 unsigned long hole_start, hole_end, size;
465 struct page *pages;
466
467 pages = NULL;
468 size = (1 << order) << PAGE_SHIFT;
469 hole_start = (image->control_page + (size - 1)) & ~(size - 1);
470 hole_end = hole_start + size - 1;
471 while (hole_end <= crashk_res.end) {
472 unsigned long i;
473
474 if (hole_end > KEXEC_CONTROL_MEMORY_LIMIT)
475 break;
476 if (hole_end > crashk_res.end)
477 break;
478 /* See if I overlap any of the segments */
479 for (i = 0; i < image->nr_segments; i++) {
480 unsigned long mstart, mend;
481
482 mstart = image->segment[i].mem;
483 mend = mstart + image->segment[i].memsz - 1;
484 if ((hole_end >= mstart) && (hole_start <= mend)) {
485 /* Advance the hole to the end of the segment */
486 hole_start = (mend + (size - 1)) & ~(size - 1);
487 hole_end = hole_start + size - 1;
488 break;
489 }
490 }
491 /* If I don't overlap any segments I have found my hole! */
492 if (i == image->nr_segments) {
493 pages = pfn_to_page(hole_start >> PAGE_SHIFT);
494 break;
495 }
496 }
497 if (pages)
498 image->control_page = hole_end;
499
500 return pages;
501 }
502
503
504 struct page *kimage_alloc_control_pages(struct kimage *image,
505 unsigned int order)
506 {
507 struct page *pages = NULL;
508
509 switch (image->type) {
510 case KEXEC_TYPE_DEFAULT:
511 pages = kimage_alloc_normal_control_pages(image, order);
512 break;
513 case KEXEC_TYPE_CRASH:
514 pages = kimage_alloc_crash_control_pages(image, order);
515 break;
516 }
517
518 return pages;
519 }
520
521 static int kimage_add_entry(struct kimage *image, kimage_entry_t entry)
522 {
523 if (*image->entry != 0)
524 image->entry++;
525
526 if (image->entry == image->last_entry) {
527 kimage_entry_t *ind_page;
528 struct page *page;
529
530 page = kimage_alloc_page(image, GFP_KERNEL, KIMAGE_NO_DEST);
531 if (!page)
532 return -ENOMEM;
533
534 ind_page = page_address(page);
535 *image->entry = virt_to_phys(ind_page) | IND_INDIRECTION;
536 image->entry = ind_page;
537 image->last_entry = ind_page +
538 ((PAGE_SIZE/sizeof(kimage_entry_t)) - 1);
539 }
540 *image->entry = entry;
541 image->entry++;
542 *image->entry = 0;
543
544 return 0;
545 }
546
547 static int kimage_set_destination(struct kimage *image,
548 unsigned long destination)
549 {
550 int result;
551
552 destination &= PAGE_MASK;
553 result = kimage_add_entry(image, destination | IND_DESTINATION);
554 if (result == 0)
555 image->destination = destination;
556
557 return result;
558 }
559
560
561 static int kimage_add_page(struct kimage *image, unsigned long page)
562 {
563 int result;
564
565 page &= PAGE_MASK;
566 result = kimage_add_entry(image, page | IND_SOURCE);
567 if (result == 0)
568 image->destination += PAGE_SIZE;
569
570 return result;
571 }
572
573
574 static void kimage_free_extra_pages(struct kimage *image)
575 {
576 /* Walk through and free any extra destination pages I may have */
577 kimage_free_page_list(&image->dest_pages);
578
579 /* Walk through and free any unuseable pages I have cached */
580 kimage_free_page_list(&image->unuseable_pages);
581
582 }
583 static int kimage_terminate(struct kimage *image)
584 {
585 if (*image->entry != 0)
586 image->entry++;
587
588 *image->entry = IND_DONE;
589
590 return 0;
591 }
592
593 #define for_each_kimage_entry(image, ptr, entry) \
594 for (ptr = &image->head; (entry = *ptr) && !(entry & IND_DONE); \
595 ptr = (entry & IND_INDIRECTION)? \
596 phys_to_virt((entry & PAGE_MASK)): ptr +1)
597
598 static void kimage_free_entry(kimage_entry_t entry)
599 {
600 struct page *page;
601
602 page = pfn_to_page(entry >> PAGE_SHIFT);
603 kimage_free_pages(page);
604 }
605
606 static void kimage_free(struct kimage *image)
607 {
608 kimage_entry_t *ptr, entry;
609 kimage_entry_t ind = 0;
610
611 if (!image)
612 return;
613
614 kimage_free_extra_pages(image);
615 for_each_kimage_entry(image, ptr, entry) {
616 if (entry & IND_INDIRECTION) {
617 /* Free the previous indirection page */
618 if (ind & IND_INDIRECTION)
619 kimage_free_entry(ind);
620 /* Save this indirection page until we are
621 * done with it.
622 */
623 ind = entry;
624 }
625 else if (entry & IND_SOURCE)
626 kimage_free_entry(entry);
627 }
628 /* Free the final indirection page */
629 if (ind & IND_INDIRECTION)
630 kimage_free_entry(ind);
631
632 /* Handle any machine specific cleanup */
633 machine_kexec_cleanup(image);
634
635 /* Free the kexec control pages... */
636 kimage_free_page_list(&image->control_pages);
637 kfree(image);
638 }
639
640 static kimage_entry_t *kimage_dst_used(struct kimage *image,
641 unsigned long page)
642 {
643 kimage_entry_t *ptr, entry;
644 unsigned long destination = 0;
645
646 for_each_kimage_entry(image, ptr, entry) {
647 if (entry & IND_DESTINATION)
648 destination = entry & PAGE_MASK;
649 else if (entry & IND_SOURCE) {
650 if (page == destination)
651 return ptr;
652 destination += PAGE_SIZE;
653 }
654 }
655
656 return NULL;
657 }
658
659 static struct page *kimage_alloc_page(struct kimage *image,
660 gfp_t gfp_mask,
661 unsigned long destination)
662 {
663 /*
664 * Here we implement safeguards to ensure that a source page
665 * is not copied to its destination page before the data on
666 * the destination page is no longer useful.
667 *
668 * To do this we maintain the invariant that a source page is
669 * either its own destination page, or it is not a
670 * destination page at all.
671 *
672 * That is slightly stronger than required, but the proof
673 * that no problems will not occur is trivial, and the
674 * implementation is simply to verify.
675 *
676 * When allocating all pages normally this algorithm will run
677 * in O(N) time, but in the worst case it will run in O(N^2)
678 * time. If the runtime is a problem the data structures can
679 * be fixed.
680 */
681 struct page *page;
682 unsigned long addr;
683
684 /*
685 * Walk through the list of destination pages, and see if I
686 * have a match.
687 */
688 list_for_each_entry(page, &image->dest_pages, lru) {
689 addr = page_to_pfn(page) << PAGE_SHIFT;
690 if (addr == destination) {
691 list_del(&page->lru);
692 return page;
693 }
694 }
695 page = NULL;
696 while (1) {
697 kimage_entry_t *old;
698
699 /* Allocate a page, if we run out of memory give up */
700 page = kimage_alloc_pages(gfp_mask, 0);
701 if (!page)
702 return NULL;
703 /* If the page cannot be used file it away */
704 if (page_to_pfn(page) >
705 (KEXEC_SOURCE_MEMORY_LIMIT >> PAGE_SHIFT)) {
706 list_add(&page->lru, &image->unuseable_pages);
707 continue;
708 }
709 addr = page_to_pfn(page) << PAGE_SHIFT;
710
711 /* If it is the destination page we want use it */
712 if (addr == destination)
713 break;
714
715 /* If the page is not a destination page use it */
716 if (!kimage_is_destination_range(image, addr,
717 addr + PAGE_SIZE))
718 break;
719
720 /*
721 * I know that the page is someones destination page.
722 * See if there is already a source page for this
723 * destination page. And if so swap the source pages.
724 */
725 old = kimage_dst_used(image, addr);
726 if (old) {
727 /* If so move it */
728 unsigned long old_addr;
729 struct page *old_page;
730
731 old_addr = *old & PAGE_MASK;
732 old_page = pfn_to_page(old_addr >> PAGE_SHIFT);
733 copy_highpage(page, old_page);
734 *old = addr | (*old & ~PAGE_MASK);
735
736 /* The old page I have found cannot be a
737 * destination page, so return it.
738 */
739 addr = old_addr;
740 page = old_page;
741 break;
742 }
743 else {
744 /* Place the page on the destination list I
745 * will use it later.
746 */
747 list_add(&page->lru, &image->dest_pages);
748 }
749 }
750
751 return page;
752 }
753
754 static int kimage_load_normal_segment(struct kimage *image,
755 struct kexec_segment *segment)
756 {
757 unsigned long maddr;
758 unsigned long ubytes, mbytes;
759 int result;
760 unsigned char __user *buf;
761
762 result = 0;
763 buf = segment->buf;
764 ubytes = segment->bufsz;
765 mbytes = segment->memsz;
766 maddr = segment->mem;
767
768 result = kimage_set_destination(image, maddr);
769 if (result < 0)
770 goto out;
771
772 while (mbytes) {
773 struct page *page;
774 char *ptr;
775 size_t uchunk, mchunk;
776
777 page = kimage_alloc_page(image, GFP_HIGHUSER, maddr);
778 if (page == 0) {
779 result = -ENOMEM;
780 goto out;
781 }
782 result = kimage_add_page(image, page_to_pfn(page)
783 << PAGE_SHIFT);
784 if (result < 0)
785 goto out;
786
787 ptr = kmap(page);
788 /* Start with a clear page */
789 memset(ptr, 0, PAGE_SIZE);
790 ptr += maddr & ~PAGE_MASK;
791 mchunk = PAGE_SIZE - (maddr & ~PAGE_MASK);
792 if (mchunk > mbytes)
793 mchunk = mbytes;
794
795 uchunk = mchunk;
796 if (uchunk > ubytes)
797 uchunk = ubytes;
798
799 result = copy_from_user(ptr, buf, uchunk);
800 kunmap(page);
801 if (result) {
802 result = (result < 0) ? result : -EIO;
803 goto out;
804 }
805 ubytes -= uchunk;
806 maddr += mchunk;
807 buf += mchunk;
808 mbytes -= mchunk;
809 }
810 out:
811 return result;
812 }
813
814 static int kimage_load_crash_segment(struct kimage *image,
815 struct kexec_segment *segment)
816 {
817 /* For crash dumps kernels we simply copy the data from
818 * user space to it's destination.
819 * We do things a page at a time for the sake of kmap.
820 */
821 unsigned long maddr;
822 unsigned long ubytes, mbytes;
823 int result;
824 unsigned char __user *buf;
825
826 result = 0;
827 buf = segment->buf;
828 ubytes = segment->bufsz;
829 mbytes = segment->memsz;
830 maddr = segment->mem;
831 while (mbytes) {
832 struct page *page;
833 char *ptr;
834 size_t uchunk, mchunk;
835
836 page = pfn_to_page(maddr >> PAGE_SHIFT);
837 if (page == 0) {
838 result = -ENOMEM;
839 goto out;
840 }
841 ptr = kmap(page);
842 ptr += maddr & ~PAGE_MASK;
843 mchunk = PAGE_SIZE - (maddr & ~PAGE_MASK);
844 if (mchunk > mbytes)
845 mchunk = mbytes;
846
847 uchunk = mchunk;
848 if (uchunk > ubytes) {
849 uchunk = ubytes;
850 /* Zero the trailing part of the page */
851 memset(ptr + uchunk, 0, mchunk - uchunk);
852 }
853 result = copy_from_user(ptr, buf, uchunk);
854 kunmap(page);
855 if (result) {
856 result = (result < 0) ? result : -EIO;
857 goto out;
858 }
859 ubytes -= uchunk;
860 maddr += mchunk;
861 buf += mchunk;
862 mbytes -= mchunk;
863 }
864 out:
865 return result;
866 }
867
868 static int kimage_load_segment(struct kimage *image,
869 struct kexec_segment *segment)
870 {
871 int result = -ENOMEM;
872
873 switch (image->type) {
874 case KEXEC_TYPE_DEFAULT:
875 result = kimage_load_normal_segment(image, segment);
876 break;
877 case KEXEC_TYPE_CRASH:
878 result = kimage_load_crash_segment(image, segment);
879 break;
880 }
881
882 return result;
883 }
884
885 /*
886 * Exec Kernel system call: for obvious reasons only root may call it.
887 *
888 * This call breaks up into three pieces.
889 * - A generic part which loads the new kernel from the current
890 * address space, and very carefully places the data in the
891 * allocated pages.
892 *
893 * - A generic part that interacts with the kernel and tells all of
894 * the devices to shut down. Preventing on-going dmas, and placing
895 * the devices in a consistent state so a later kernel can
896 * reinitialize them.
897 *
898 * - A machine specific part that includes the syscall number
899 * and the copies the image to it's final destination. And
900 * jumps into the image at entry.
901 *
902 * kexec does not sync, or unmount filesystems so if you need
903 * that to happen you need to do that yourself.
904 */
905 struct kimage *kexec_image = NULL;
906 static struct kimage *kexec_crash_image = NULL;
907 /*
908 * A home grown binary mutex.
909 * Nothing can wait so this mutex is safe to use
910 * in interrupt context :)
911 */
912 static int kexec_lock = 0;
913
914 asmlinkage long sys_kexec_load(unsigned long entry, unsigned long nr_segments,
915 struct kexec_segment __user *segments,
916 unsigned long flags)
917 {
918 struct kimage **dest_image, *image;
919 int locked;
920 int result;
921
922 /* We only trust the superuser with rebooting the system. */
923 if (!capable(CAP_SYS_BOOT))
924 return -EPERM;
925
926 /*
927 * Verify we have a legal set of flags
928 * This leaves us room for future extensions.
929 */
930 if ((flags & KEXEC_FLAGS) != (flags & ~KEXEC_ARCH_MASK))
931 return -EINVAL;
932
933 /* Verify we are on the appropriate architecture */
934 if (((flags & KEXEC_ARCH_MASK) != KEXEC_ARCH) &&
935 ((flags & KEXEC_ARCH_MASK) != KEXEC_ARCH_DEFAULT))
936 return -EINVAL;
937
938 /* Put an artificial cap on the number
939 * of segments passed to kexec_load.
940 */
941 if (nr_segments > KEXEC_SEGMENT_MAX)
942 return -EINVAL;
943
944 image = NULL;
945 result = 0;
946
947 /* Because we write directly to the reserved memory
948 * region when loading crash kernels we need a mutex here to
949 * prevent multiple crash kernels from attempting to load
950 * simultaneously, and to prevent a crash kernel from loading
951 * over the top of a in use crash kernel.
952 *
953 * KISS: always take the mutex.
954 */
955 locked = xchg(&kexec_lock, 1);
956 if (locked)
957 return -EBUSY;
958
959 dest_image = &kexec_image;
960 if (flags & KEXEC_ON_CRASH)
961 dest_image = &kexec_crash_image;
962 if (nr_segments > 0) {
963 unsigned long i;
964
965 /* Loading another kernel to reboot into */
966 if ((flags & KEXEC_ON_CRASH) == 0)
967 result = kimage_normal_alloc(&image, entry,
968 nr_segments, segments);
969 /* Loading another kernel to switch to if this one crashes */
970 else if (flags & KEXEC_ON_CRASH) {
971 /* Free any current crash dump kernel before
972 * we corrupt it.
973 */
974 kimage_free(xchg(&kexec_crash_image, NULL));
975 result = kimage_crash_alloc(&image, entry,
976 nr_segments, segments);
977 }
978 if (result)
979 goto out;
980
981 result = machine_kexec_prepare(image);
982 if (result)
983 goto out;
984
985 for (i = 0; i < nr_segments; i++) {
986 result = kimage_load_segment(image, &image->segment[i]);
987 if (result)
988 goto out;
989 }
990 result = kimage_terminate(image);
991 if (result)
992 goto out;
993 }
994 /* Install the new kernel, and Uninstall the old */
995 image = xchg(dest_image, image);
996
997 out:
998 xchg(&kexec_lock, 0); /* Release the mutex */
999 kimage_free(image);
1000
1001 return result;
1002 }
1003
1004 #ifdef CONFIG_COMPAT
1005 asmlinkage long compat_sys_kexec_load(unsigned long entry,
1006 unsigned long nr_segments,
1007 struct compat_kexec_segment __user *segments,
1008 unsigned long flags)
1009 {
1010 struct compat_kexec_segment in;
1011 struct kexec_segment out, __user *ksegments;
1012 unsigned long i, result;
1013
1014 /* Don't allow clients that don't understand the native
1015 * architecture to do anything.
1016 */
1017 if ((flags & KEXEC_ARCH_MASK) == KEXEC_ARCH_DEFAULT)
1018 return -EINVAL;
1019
1020 if (nr_segments > KEXEC_SEGMENT_MAX)
1021 return -EINVAL;
1022
1023 ksegments = compat_alloc_user_space(nr_segments * sizeof(out));
1024 for (i=0; i < nr_segments; i++) {
1025 result = copy_from_user(&in, &segments[i], sizeof(in));
1026 if (result)
1027 return -EFAULT;
1028
1029 out.buf = compat_ptr(in.buf);
1030 out.bufsz = in.bufsz;
1031 out.mem = in.mem;
1032 out.memsz = in.memsz;
1033
1034 result = copy_to_user(&ksegments[i], &out, sizeof(out));
1035 if (result)
1036 return -EFAULT;
1037 }
1038
1039 return sys_kexec_load(entry, nr_segments, ksegments, flags);
1040 }
1041 #endif
1042
1043 void crash_kexec(struct pt_regs *regs)
1044 {
1045 struct kimage *image;
1046 int locked;
1047
1048
1049 /* Take the kexec_lock here to prevent sys_kexec_load
1050 * running on one cpu from replacing the crash kernel
1051 * we are using after a panic on a different cpu.
1052 *
1053 * If the crash kernel was not located in a fixed area
1054 * of memory the xchg(&kexec_crash_image) would be
1055 * sufficient. But since I reuse the memory...
1056 */
1057 locked = xchg(&kexec_lock, 1);
1058 if (!locked) {
1059 image = xchg(&kexec_crash_image, NULL);
1060 if (image) {
1061 struct pt_regs fixed_regs;
1062 crash_setup_regs(&fixed_regs, regs);
1063 machine_crash_shutdown(&fixed_regs);
1064 machine_kexec(image);
1065 }
1066 xchg(&kexec_lock, 0);
1067 }
1068 }
1069
1070 static int __init crash_notes_memory_init(void)
1071 {
1072 /* Allocate memory for saving cpu registers. */
1073 crash_notes = alloc_percpu(note_buf_t);
1074 if (!crash_notes) {
1075 printk("Kexec: Memory allocation for saving cpu register"
1076 " states failed\n");
1077 return -ENOMEM;
1078 }
1079 return 0;
1080 }
1081 module_init(crash_notes_memory_init)
1082
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.