kfifo: move struct kfifo in place
[linux-2.6.git] / kernel / kexec.c
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/mutex.h>
16 #include <linux/list.h>
17 #include <linux/highmem.h>
18 #include <linux/syscalls.h>
19 #include <linux/reboot.h>
20 #include <linux/ioport.h>
21 #include <linux/hardirq.h>
22 #include <linux/elf.h>
23 #include <linux/elfcore.h>
24 #include <generated/utsrelease.h>
25 #include <linux/utsname.h>
26 #include <linux/numa.h>
27 #include <linux/suspend.h>
28 #include <linux/device.h>
29 #include <linux/freezer.h>
30 #include <linux/pm.h>
31 #include <linux/cpu.h>
32 #include <linux/console.h>
33 #include <linux/vmalloc.h>
34 #include <linux/swap.h>
35
36 #include <asm/page.h>
37 #include <asm/uaccess.h>
38 #include <asm/io.h>
39 #include <asm/system.h>
40 #include <asm/sections.h>
41
42 /* Per cpu memory for storing cpu states in case of system crash. */
43 note_buf_t* crash_notes;
44
45 /* vmcoreinfo stuff */
46 static unsigned char vmcoreinfo_data[VMCOREINFO_BYTES];
47 u32 vmcoreinfo_note[VMCOREINFO_NOTE_SIZE/4];
48 size_t vmcoreinfo_size;
49 size_t vmcoreinfo_max_size = sizeof(vmcoreinfo_data);
50
51 /* Location of the reserved area for the crash kernel */
52 struct resource crashk_res = {
53         .name  = "Crash kernel",
54         .start = 0,
55         .end   = 0,
56         .flags = IORESOURCE_BUSY | IORESOURCE_MEM
57 };
58
59 int kexec_should_crash(struct task_struct *p)
60 {
61         if (in_interrupt() || !p->pid || is_global_init(p) || panic_on_oops)
62                 return 1;
63         return 0;
64 }
65
66 /*
67  * When kexec transitions to the new kernel there is a one-to-one
68  * mapping between physical and virtual addresses.  On processors
69  * where you can disable the MMU this is trivial, and easy.  For
70  * others it is still a simple predictable page table to setup.
71  *
72  * In that environment kexec copies the new kernel to its final
73  * resting place.  This means I can only support memory whose
74  * physical address can fit in an unsigned long.  In particular
75  * addresses where (pfn << PAGE_SHIFT) > ULONG_MAX cannot be handled.
76  * If the assembly stub has more restrictive requirements
77  * KEXEC_SOURCE_MEMORY_LIMIT and KEXEC_DEST_MEMORY_LIMIT can be
78  * defined more restrictively in <asm/kexec.h>.
79  *
80  * The code for the transition from the current kernel to the
81  * the new kernel is placed in the control_code_buffer, whose size
82  * is given by KEXEC_CONTROL_PAGE_SIZE.  In the best case only a single
83  * page of memory is necessary, but some architectures require more.
84  * Because this memory must be identity mapped in the transition from
85  * virtual to physical addresses it must live in the range
86  * 0 - TASK_SIZE, as only the user space mappings are arbitrarily
87  * modifiable.
88  *
89  * The assembly stub in the control code buffer is passed a linked list
90  * of descriptor pages detailing the source pages of the new kernel,
91  * and the destination addresses of those source pages.  As this data
92  * structure is not used in the context of the current OS, it must
93  * be self-contained.
94  *
95  * The code has been made to work with highmem pages and will use a
96  * destination page in its final resting place (if it happens
97  * to allocate it).  The end product of this is that most of the
98  * physical address space, and most of RAM can be used.
99  *
100  * Future directions include:
101  *  - allocating a page table with the control code buffer identity
102  *    mapped, to simplify machine_kexec and make kexec_on_panic more
103  *    reliable.
104  */
105
106 /*
107  * KIMAGE_NO_DEST is an impossible destination address..., for
108  * allocating pages whose destination address we do not care about.
109  */
110 #define KIMAGE_NO_DEST (-1UL)
111
112 static int kimage_is_destination_range(struct kimage *image,
113                                        unsigned long start, unsigned long end);
114 static struct page *kimage_alloc_page(struct kimage *image,
115                                        gfp_t gfp_mask,
116                                        unsigned long dest);
117
118 static int do_kimage_alloc(struct kimage **rimage, unsigned long entry,
119                             unsigned long nr_segments,
120                             struct kexec_segment __user *segments)
121 {
122         size_t segment_bytes;
123         struct kimage *image;
124         unsigned long i;
125         int result;
126
127         /* Allocate a controlling structure */
128         result = -ENOMEM;
129         image = kzalloc(sizeof(*image), GFP_KERNEL);
130         if (!image)
131                 goto out;
132
133         image->head = 0;
134         image->entry = &image->head;
135         image->last_entry = &image->head;
136         image->control_page = ~0; /* By default this does not apply */
137         image->start = entry;
138         image->type = KEXEC_TYPE_DEFAULT;
139
140         /* Initialize the list of control pages */
141         INIT_LIST_HEAD(&image->control_pages);
142
143         /* Initialize the list of destination pages */
144         INIT_LIST_HEAD(&image->dest_pages);
145
146         /* Initialize the list of unuseable pages */
147         INIT_LIST_HEAD(&image->unuseable_pages);
148
149         /* Read in the segments */
150         image->nr_segments = nr_segments;
151         segment_bytes = nr_segments * sizeof(*segments);
152         result = copy_from_user(image->segment, segments, segment_bytes);
153         if (result)
154                 goto out;
155
156         /*
157          * Verify we have good destination addresses.  The caller is
158          * responsible for making certain we don't attempt to load
159          * the new image into invalid or reserved areas of RAM.  This
160          * just verifies it is an address we can use.
161          *
162          * Since the kernel does everything in page size chunks ensure
163          * the destination addreses are page aligned.  Too many
164          * special cases crop of when we don't do this.  The most
165          * insidious is getting overlapping destination addresses
166          * simply because addresses are changed to page size
167          * granularity.
168          */
169         result = -EADDRNOTAVAIL;
170         for (i = 0; i < nr_segments; i++) {
171                 unsigned long mstart, mend;
172
173                 mstart = image->segment[i].mem;
174                 mend   = mstart + image->segment[i].memsz;
175                 if ((mstart & ~PAGE_MASK) || (mend & ~PAGE_MASK))
176                         goto out;
177                 if (mend >= KEXEC_DESTINATION_MEMORY_LIMIT)
178                         goto out;
179         }
180
181         /* Verify our destination addresses do not overlap.
182          * If we alloed overlapping destination addresses
183          * through very weird things can happen with no
184          * easy explanation as one segment stops on another.
185          */
186         result = -EINVAL;
187         for (i = 0; i < nr_segments; i++) {
188                 unsigned long mstart, mend;
189                 unsigned long j;
190
191                 mstart = image->segment[i].mem;
192                 mend   = mstart + image->segment[i].memsz;
193                 for (j = 0; j < i; j++) {
194                         unsigned long pstart, pend;
195                         pstart = image->segment[j].mem;
196                         pend   = pstart + image->segment[j].memsz;
197                         /* Do the segments overlap ? */
198                         if ((mend > pstart) && (mstart < pend))
199                                 goto out;
200                 }
201         }
202
203         /* Ensure our buffer sizes are strictly less than
204          * our memory sizes.  This should always be the case,
205          * and it is easier to check up front than to be surprised
206          * later on.
207          */
208         result = -EINVAL;
209         for (i = 0; i < nr_segments; i++) {
210                 if (image->segment[i].bufsz > image->segment[i].memsz)
211                         goto out;
212         }
213
214         result = 0;
215 out:
216         if (result == 0)
217                 *rimage = image;
218         else
219                 kfree(image);
220
221         return result;
222
223 }
224
225 static int kimage_normal_alloc(struct kimage **rimage, unsigned long entry,
226                                 unsigned long nr_segments,
227                                 struct kexec_segment __user *segments)
228 {
229         int result;
230         struct kimage *image;
231
232         /* Allocate and initialize a controlling structure */
233         image = NULL;
234         result = do_kimage_alloc(&image, entry, nr_segments, segments);
235         if (result)
236                 goto out;
237
238         *rimage = image;
239
240         /*
241          * Find a location for the control code buffer, and add it
242          * the vector of segments so that it's pages will also be
243          * counted as destination pages.
244          */
245         result = -ENOMEM;
246         image->control_code_page = kimage_alloc_control_pages(image,
247                                            get_order(KEXEC_CONTROL_PAGE_SIZE));
248         if (!image->control_code_page) {
249                 printk(KERN_ERR "Could not allocate control_code_buffer\n");
250                 goto out;
251         }
252
253         image->swap_page = kimage_alloc_control_pages(image, 0);
254         if (!image->swap_page) {
255                 printk(KERN_ERR "Could not allocate swap buffer\n");
256                 goto out;
257         }
258
259         result = 0;
260  out:
261         if (result == 0)
262                 *rimage = image;
263         else
264                 kfree(image);
265
266         return result;
267 }
268
269 static int kimage_crash_alloc(struct kimage **rimage, unsigned long entry,
270                                 unsigned long nr_segments,
271                                 struct kexec_segment __user *segments)
272 {
273         int result;
274         struct kimage *image;
275         unsigned long i;
276
277         image = NULL;
278         /* Verify we have a valid entry point */
279         if ((entry < crashk_res.start) || (entry > crashk_res.end)) {
280                 result = -EADDRNOTAVAIL;
281                 goto out;
282         }
283
284         /* Allocate and initialize a controlling structure */
285         result = do_kimage_alloc(&image, entry, nr_segments, segments);
286         if (result)
287                 goto out;
288
289         /* Enable the special crash kernel control page
290          * allocation policy.
291          */
292         image->control_page = crashk_res.start;
293         image->type = KEXEC_TYPE_CRASH;
294
295         /*
296          * Verify we have good destination addresses.  Normally
297          * the caller is responsible for making certain we don't
298          * attempt to load the new image into invalid or reserved
299          * areas of RAM.  But crash kernels are preloaded into a
300          * reserved area of ram.  We must ensure the addresses
301          * are in the reserved area otherwise preloading the
302          * kernel could corrupt things.
303          */
304         result = -EADDRNOTAVAIL;
305         for (i = 0; i < nr_segments; i++) {
306                 unsigned long mstart, mend;
307
308                 mstart = image->segment[i].mem;
309                 mend = mstart + image->segment[i].memsz - 1;
310                 /* Ensure we are within the crash kernel limits */
311                 if ((mstart < crashk_res.start) || (mend > crashk_res.end))
312                         goto out;
313         }
314
315         /*
316          * Find a location for the control code buffer, and add
317          * the vector of segments so that it's pages will also be
318          * counted as destination pages.
319          */
320         result = -ENOMEM;
321         image->control_code_page = kimage_alloc_control_pages(image,
322                                            get_order(KEXEC_CONTROL_PAGE_SIZE));
323         if (!image->control_code_page) {
324                 printk(KERN_ERR "Could not allocate control_code_buffer\n");
325                 goto out;
326         }
327
328         result = 0;
329 out:
330         if (result == 0)
331                 *rimage = image;
332         else
333                 kfree(image);
334
335         return result;
336 }
337
338 static int kimage_is_destination_range(struct kimage *image,
339                                         unsigned long start,
340                                         unsigned long end)
341 {
342         unsigned long i;
343
344         for (i = 0; i < image->nr_segments; i++) {
345                 unsigned long mstart, mend;
346
347                 mstart = image->segment[i].mem;
348                 mend = mstart + image->segment[i].memsz;
349                 if ((end > mstart) && (start < mend))
350                         return 1;
351         }
352
353         return 0;
354 }
355
356 static struct page *kimage_alloc_pages(gfp_t gfp_mask, unsigned int order)
357 {
358         struct page *pages;
359
360         pages = alloc_pages(gfp_mask, order);
361         if (pages) {
362                 unsigned int count, i;
363                 pages->mapping = NULL;
364                 set_page_private(pages, order);
365                 count = 1 << order;
366                 for (i = 0; i < count; i++)
367                         SetPageReserved(pages + i);
368         }
369
370         return pages;
371 }
372
373 static void kimage_free_pages(struct page *page)
374 {
375         unsigned int order, count, i;
376
377         order = page_private(page);
378         count = 1 << order;
379         for (i = 0; i < count; i++)
380                 ClearPageReserved(page + i);
381         __free_pages(page, order);
382 }
383
384 static void kimage_free_page_list(struct list_head *list)
385 {
386         struct list_head *pos, *next;
387
388         list_for_each_safe(pos, next, list) {
389                 struct page *page;
390
391                 page = list_entry(pos, struct page, lru);
392                 list_del(&page->lru);
393                 kimage_free_pages(page);
394         }
395 }
396
397 static struct page *kimage_alloc_normal_control_pages(struct kimage *image,
398                                                         unsigned int order)
399 {
400         /* Control pages are special, they are the intermediaries
401          * that are needed while we copy the rest of the pages
402          * to their final resting place.  As such they must
403          * not conflict with either the destination addresses
404          * or memory the kernel is already using.
405          *
406          * The only case where we really need more than one of
407          * these are for architectures where we cannot disable
408          * the MMU and must instead generate an identity mapped
409          * page table for all of the memory.
410          *
411          * At worst this runs in O(N) of the image size.
412          */
413         struct list_head extra_pages;
414         struct page *pages;
415         unsigned int count;
416
417         count = 1 << order;
418         INIT_LIST_HEAD(&extra_pages);
419
420         /* Loop while I can allocate a page and the page allocated
421          * is a destination page.
422          */
423         do {
424                 unsigned long pfn, epfn, addr, eaddr;
425
426                 pages = kimage_alloc_pages(GFP_KERNEL, order);
427                 if (!pages)
428                         break;
429                 pfn   = page_to_pfn(pages);
430                 epfn  = pfn + count;
431                 addr  = pfn << PAGE_SHIFT;
432                 eaddr = epfn << PAGE_SHIFT;
433                 if ((epfn >= (KEXEC_CONTROL_MEMORY_LIMIT >> PAGE_SHIFT)) ||
434                               kimage_is_destination_range(image, addr, eaddr)) {
435                         list_add(&pages->lru, &extra_pages);
436                         pages = NULL;
437                 }
438         } while (!pages);
439
440         if (pages) {
441                 /* Remember the allocated page... */
442                 list_add(&pages->lru, &image->control_pages);
443
444                 /* Because the page is already in it's destination
445                  * location we will never allocate another page at
446                  * that address.  Therefore kimage_alloc_pages
447                  * will not return it (again) and we don't need
448                  * to give it an entry in image->segment[].
449                  */
450         }
451         /* Deal with the destination pages I have inadvertently allocated.
452          *
453          * Ideally I would convert multi-page allocations into single
454          * page allocations, and add everyting to image->dest_pages.
455          *
456          * For now it is simpler to just free the pages.
457          */
458         kimage_free_page_list(&extra_pages);
459
460         return pages;
461 }
462
463 static struct page *kimage_alloc_crash_control_pages(struct kimage *image,
464                                                       unsigned int order)
465 {
466         /* Control pages are special, they are the intermediaries
467          * that are needed while we copy the rest of the pages
468          * to their final resting place.  As such they must
469          * not conflict with either the destination addresses
470          * or memory the kernel is already using.
471          *
472          * Control pages are also the only pags we must allocate
473          * when loading a crash kernel.  All of the other pages
474          * are specified by the segments and we just memcpy
475          * into them directly.
476          *
477          * The only case where we really need more than one of
478          * these are for architectures where we cannot disable
479          * the MMU and must instead generate an identity mapped
480          * page table for all of the memory.
481          *
482          * Given the low demand this implements a very simple
483          * allocator that finds the first hole of the appropriate
484          * size in the reserved memory region, and allocates all
485          * of the memory up to and including the hole.
486          */
487         unsigned long hole_start, hole_end, size;
488         struct page *pages;
489
490         pages = NULL;
491         size = (1 << order) << PAGE_SHIFT;
492         hole_start = (image->control_page + (size - 1)) & ~(size - 1);
493         hole_end   = hole_start + size - 1;
494         while (hole_end <= crashk_res.end) {
495                 unsigned long i;
496
497                 if (hole_end > KEXEC_CONTROL_MEMORY_LIMIT)
498                         break;
499                 if (hole_end > crashk_res.end)
500                         break;
501                 /* See if I overlap any of the segments */
502                 for (i = 0; i < image->nr_segments; i++) {
503                         unsigned long mstart, mend;
504
505                         mstart = image->segment[i].mem;
506                         mend   = mstart + image->segment[i].memsz - 1;
507                         if ((hole_end >= mstart) && (hole_start <= mend)) {
508                                 /* Advance the hole to the end of the segment */
509                                 hole_start = (mend + (size - 1)) & ~(size - 1);
510                                 hole_end   = hole_start + size - 1;
511                                 break;
512                         }
513                 }
514                 /* If I don't overlap any segments I have found my hole! */
515                 if (i == image->nr_segments) {
516                         pages = pfn_to_page(hole_start >> PAGE_SHIFT);
517                         break;
518                 }
519         }
520         if (pages)
521                 image->control_page = hole_end;
522
523         return pages;
524 }
525
526
527 struct page *kimage_alloc_control_pages(struct kimage *image,
528                                          unsigned int order)
529 {
530         struct page *pages = NULL;
531
532         switch (image->type) {
533         case KEXEC_TYPE_DEFAULT:
534                 pages = kimage_alloc_normal_control_pages(image, order);
535                 break;
536         case KEXEC_TYPE_CRASH:
537                 pages = kimage_alloc_crash_control_pages(image, order);
538                 break;
539         }
540
541         return pages;
542 }
543
544 static int kimage_add_entry(struct kimage *image, kimage_entry_t entry)
545 {
546         if (*image->entry != 0)
547                 image->entry++;
548
549         if (image->entry == image->last_entry) {
550                 kimage_entry_t *ind_page;
551                 struct page *page;
552
553                 page = kimage_alloc_page(image, GFP_KERNEL, KIMAGE_NO_DEST);
554                 if (!page)
555                         return -ENOMEM;
556
557                 ind_page = page_address(page);
558                 *image->entry = virt_to_phys(ind_page) | IND_INDIRECTION;
559                 image->entry = ind_page;
560                 image->last_entry = ind_page +
561                                       ((PAGE_SIZE/sizeof(kimage_entry_t)) - 1);
562         }
563         *image->entry = entry;
564         image->entry++;
565         *image->entry = 0;
566
567         return 0;
568 }
569
570 static int kimage_set_destination(struct kimage *image,
571                                    unsigned long destination)
572 {
573         int result;
574
575         destination &= PAGE_MASK;
576         result = kimage_add_entry(image, destination | IND_DESTINATION);
577         if (result == 0)
578                 image->destination = destination;
579
580         return result;
581 }
582
583
584 static int kimage_add_page(struct kimage *image, unsigned long page)
585 {
586         int result;
587
588         page &= PAGE_MASK;
589         result = kimage_add_entry(image, page | IND_SOURCE);
590         if (result == 0)
591                 image->destination += PAGE_SIZE;
592
593         return result;
594 }
595
596
597 static void kimage_free_extra_pages(struct kimage *image)
598 {
599         /* Walk through and free any extra destination pages I may have */
600         kimage_free_page_list(&image->dest_pages);
601
602         /* Walk through and free any unuseable pages I have cached */
603         kimage_free_page_list(&image->unuseable_pages);
604
605 }
606 static void kimage_terminate(struct kimage *image)
607 {
608         if (*image->entry != 0)
609                 image->entry++;
610
611         *image->entry = IND_DONE;
612 }
613
614 #define for_each_kimage_entry(image, ptr, entry) \
615         for (ptr = &image->head; (entry = *ptr) && !(entry & IND_DONE); \
616                 ptr = (entry & IND_INDIRECTION)? \
617                         phys_to_virt((entry & PAGE_MASK)): ptr +1)
618
619 static void kimage_free_entry(kimage_entry_t entry)
620 {
621         struct page *page;
622
623         page = pfn_to_page(entry >> PAGE_SHIFT);
624         kimage_free_pages(page);
625 }
626
627 static void kimage_free(struct kimage *image)
628 {
629         kimage_entry_t *ptr, entry;
630         kimage_entry_t ind = 0;
631
632         if (!image)
633                 return;
634
635         kimage_free_extra_pages(image);
636         for_each_kimage_entry(image, ptr, entry) {
637                 if (entry & IND_INDIRECTION) {
638                         /* Free the previous indirection page */
639                         if (ind & IND_INDIRECTION)
640                                 kimage_free_entry(ind);
641                         /* Save this indirection page until we are
642                          * done with it.
643                          */
644                         ind = entry;
645                 }
646                 else if (entry & IND_SOURCE)
647                         kimage_free_entry(entry);
648         }
649         /* Free the final indirection page */
650         if (ind & IND_INDIRECTION)
651                 kimage_free_entry(ind);
652
653         /* Handle any machine specific cleanup */
654         machine_kexec_cleanup(image);
655
656         /* Free the kexec control pages... */
657         kimage_free_page_list(&image->control_pages);
658         kfree(image);
659 }
660
661 static kimage_entry_t *kimage_dst_used(struct kimage *image,
662                                         unsigned long page)
663 {
664         kimage_entry_t *ptr, entry;
665         unsigned long destination = 0;
666
667         for_each_kimage_entry(image, ptr, entry) {
668                 if (entry & IND_DESTINATION)
669                         destination = entry & PAGE_MASK;
670                 else if (entry & IND_SOURCE) {
671                         if (page == destination)
672                                 return ptr;
673                         destination += PAGE_SIZE;
674                 }
675         }
676
677         return NULL;
678 }
679
680 static struct page *kimage_alloc_page(struct kimage *image,
681                                         gfp_t gfp_mask,
682                                         unsigned long destination)
683 {
684         /*
685          * Here we implement safeguards to ensure that a source page
686          * is not copied to its destination page before the data on
687          * the destination page is no longer useful.
688          *
689          * To do this we maintain the invariant that a source page is
690          * either its own destination page, or it is not a
691          * destination page at all.
692          *
693          * That is slightly stronger than required, but the proof
694          * that no problems will not occur is trivial, and the
695          * implementation is simply to verify.
696          *
697          * When allocating all pages normally this algorithm will run
698          * in O(N) time, but in the worst case it will run in O(N^2)
699          * time.   If the runtime is a problem the data structures can
700          * be fixed.
701          */
702         struct page *page;
703         unsigned long addr;
704
705         /*
706          * Walk through the list of destination pages, and see if I
707          * have a match.
708          */
709         list_for_each_entry(page, &image->dest_pages, lru) {
710                 addr = page_to_pfn(page) << PAGE_SHIFT;
711                 if (addr == destination) {
712                         list_del(&page->lru);
713                         return page;
714                 }
715         }
716         page = NULL;
717         while (1) {
718                 kimage_entry_t *old;
719
720                 /* Allocate a page, if we run out of memory give up */
721                 page = kimage_alloc_pages(gfp_mask, 0);
722                 if (!page)
723                         return NULL;
724                 /* If the page cannot be used file it away */
725                 if (page_to_pfn(page) >
726                                 (KEXEC_SOURCE_MEMORY_LIMIT >> PAGE_SHIFT)) {
727                         list_add(&page->lru, &image->unuseable_pages);
728                         continue;
729                 }
730                 addr = page_to_pfn(page) << PAGE_SHIFT;
731
732                 /* If it is the destination page we want use it */
733                 if (addr == destination)
734                         break;
735
736                 /* If the page is not a destination page use it */
737                 if (!kimage_is_destination_range(image, addr,
738                                                   addr + PAGE_SIZE))
739                         break;
740
741                 /*
742                  * I know that the page is someones destination page.
743                  * See if there is already a source page for this
744                  * destination page.  And if so swap the source pages.
745                  */
746                 old = kimage_dst_used(image, addr);
747                 if (old) {
748                         /* If so move it */
749                         unsigned long old_addr;
750                         struct page *old_page;
751
752                         old_addr = *old & PAGE_MASK;
753                         old_page = pfn_to_page(old_addr >> PAGE_SHIFT);
754                         copy_highpage(page, old_page);
755                         *old = addr | (*old & ~PAGE_MASK);
756
757                         /* The old page I have found cannot be a
758                          * destination page, so return it if it's
759                          * gfp_flags honor the ones passed in.
760                          */
761                         if (!(gfp_mask & __GFP_HIGHMEM) &&
762                             PageHighMem(old_page)) {
763                                 kimage_free_pages(old_page);
764                                 continue;
765                         }
766                         addr = old_addr;
767                         page = old_page;
768                         break;
769                 }
770                 else {
771                         /* Place the page on the destination list I
772                          * will use it later.
773                          */
774                         list_add(&page->lru, &image->dest_pages);
775                 }
776         }
777
778         return page;
779 }
780
781 static int kimage_load_normal_segment(struct kimage *image,
782                                          struct kexec_segment *segment)
783 {
784         unsigned long maddr;
785         unsigned long ubytes, mbytes;
786         int result;
787         unsigned char __user *buf;
788
789         result = 0;
790         buf = segment->buf;
791         ubytes = segment->bufsz;
792         mbytes = segment->memsz;
793         maddr = segment->mem;
794
795         result = kimage_set_destination(image, maddr);
796         if (result < 0)
797                 goto out;
798
799         while (mbytes) {
800                 struct page *page;
801                 char *ptr;
802                 size_t uchunk, mchunk;
803
804                 page = kimage_alloc_page(image, GFP_HIGHUSER, maddr);
805                 if (!page) {
806                         result  = -ENOMEM;
807                         goto out;
808                 }
809                 result = kimage_add_page(image, page_to_pfn(page)
810                                                                 << PAGE_SHIFT);
811                 if (result < 0)
812                         goto out;
813
814                 ptr = kmap(page);
815                 /* Start with a clear page */
816                 memset(ptr, 0, PAGE_SIZE);
817                 ptr += maddr & ~PAGE_MASK;
818                 mchunk = PAGE_SIZE - (maddr & ~PAGE_MASK);
819                 if (mchunk > mbytes)
820                         mchunk = mbytes;
821
822                 uchunk = mchunk;
823                 if (uchunk > ubytes)
824                         uchunk = ubytes;
825
826                 result = copy_from_user(ptr, buf, uchunk);
827                 kunmap(page);
828                 if (result) {
829                         result = (result < 0) ? result : -EIO;
830                         goto out;
831                 }
832                 ubytes -= uchunk;
833                 maddr  += mchunk;
834                 buf    += mchunk;
835                 mbytes -= mchunk;
836         }
837 out:
838         return result;
839 }
840
841 static int kimage_load_crash_segment(struct kimage *image,
842                                         struct kexec_segment *segment)
843 {
844         /* For crash dumps kernels we simply copy the data from
845          * user space to it's destination.
846          * We do things a page at a time for the sake of kmap.
847          */
848         unsigned long maddr;
849         unsigned long ubytes, mbytes;
850         int result;
851         unsigned char __user *buf;
852
853         result = 0;
854         buf = segment->buf;
855         ubytes = segment->bufsz;
856         mbytes = segment->memsz;
857         maddr = segment->mem;
858         while (mbytes) {
859                 struct page *page;
860                 char *ptr;
861                 size_t uchunk, mchunk;
862
863                 page = pfn_to_page(maddr >> PAGE_SHIFT);
864                 if (!page) {
865                         result  = -ENOMEM;
866                         goto out;
867                 }
868                 ptr = kmap(page);
869                 ptr += maddr & ~PAGE_MASK;
870                 mchunk = PAGE_SIZE - (maddr & ~PAGE_MASK);
871                 if (mchunk > mbytes)
872                         mchunk = mbytes;
873
874                 uchunk = mchunk;
875                 if (uchunk > ubytes) {
876                         uchunk = ubytes;
877                         /* Zero the trailing part of the page */
878                         memset(ptr + uchunk, 0, mchunk - uchunk);
879                 }
880                 result = copy_from_user(ptr, buf, uchunk);
881                 kexec_flush_icache_page(page);
882                 kunmap(page);
883                 if (result) {
884                         result = (result < 0) ? result : -EIO;
885                         goto out;
886                 }
887                 ubytes -= uchunk;
888                 maddr  += mchunk;
889                 buf    += mchunk;
890                 mbytes -= mchunk;
891         }
892 out:
893         return result;
894 }
895
896 static int kimage_load_segment(struct kimage *image,
897                                 struct kexec_segment *segment)
898 {
899         int result = -ENOMEM;
900
901         switch (image->type) {
902         case KEXEC_TYPE_DEFAULT:
903                 result = kimage_load_normal_segment(image, segment);
904                 break;
905         case KEXEC_TYPE_CRASH:
906                 result = kimage_load_crash_segment(image, segment);
907                 break;
908         }
909
910         return result;
911 }
912
913 /*
914  * Exec Kernel system call: for obvious reasons only root may call it.
915  *
916  * This call breaks up into three pieces.
917  * - A generic part which loads the new kernel from the current
918  *   address space, and very carefully places the data in the
919  *   allocated pages.
920  *
921  * - A generic part that interacts with the kernel and tells all of
922  *   the devices to shut down.  Preventing on-going dmas, and placing
923  *   the devices in a consistent state so a later kernel can
924  *   reinitialize them.
925  *
926  * - A machine specific part that includes the syscall number
927  *   and the copies the image to it's final destination.  And
928  *   jumps into the image at entry.
929  *
930  * kexec does not sync, or unmount filesystems so if you need
931  * that to happen you need to do that yourself.
932  */
933 struct kimage *kexec_image;
934 struct kimage *kexec_crash_image;
935
936 static DEFINE_MUTEX(kexec_mutex);
937
938 SYSCALL_DEFINE4(kexec_load, unsigned long, entry, unsigned long, nr_segments,
939                 struct kexec_segment __user *, segments, unsigned long, flags)
940 {
941         struct kimage **dest_image, *image;
942         int result;
943
944         /* We only trust the superuser with rebooting the system. */
945         if (!capable(CAP_SYS_BOOT))
946                 return -EPERM;
947
948         /*
949          * Verify we have a legal set of flags
950          * This leaves us room for future extensions.
951          */
952         if ((flags & KEXEC_FLAGS) != (flags & ~KEXEC_ARCH_MASK))
953                 return -EINVAL;
954
955         /* Verify we are on the appropriate architecture */
956         if (((flags & KEXEC_ARCH_MASK) != KEXEC_ARCH) &&
957                 ((flags & KEXEC_ARCH_MASK) != KEXEC_ARCH_DEFAULT))
958                 return -EINVAL;
959
960         /* Put an artificial cap on the number
961          * of segments passed to kexec_load.
962          */
963         if (nr_segments > KEXEC_SEGMENT_MAX)
964                 return -EINVAL;
965
966         image = NULL;
967         result = 0;
968
969         /* Because we write directly to the reserved memory
970          * region when loading crash kernels we need a mutex here to
971          * prevent multiple crash  kernels from attempting to load
972          * simultaneously, and to prevent a crash kernel from loading
973          * over the top of a in use crash kernel.
974          *
975          * KISS: always take the mutex.
976          */
977         if (!mutex_trylock(&kexec_mutex))
978                 return -EBUSY;
979
980         dest_image = &kexec_image;
981         if (flags & KEXEC_ON_CRASH)
982                 dest_image = &kexec_crash_image;
983         if (nr_segments > 0) {
984                 unsigned long i;
985
986                 /* Loading another kernel to reboot into */
987                 if ((flags & KEXEC_ON_CRASH) == 0)
988                         result = kimage_normal_alloc(&image, entry,
989                                                         nr_segments, segments);
990                 /* Loading another kernel to switch to if this one crashes */
991                 else if (flags & KEXEC_ON_CRASH) {
992                         /* Free any current crash dump kernel before
993                          * we corrupt it.
994                          */
995                         kimage_free(xchg(&kexec_crash_image, NULL));
996                         result = kimage_crash_alloc(&image, entry,
997                                                      nr_segments, segments);
998                 }
999                 if (result)
1000                         goto out;
1001
1002                 if (flags & KEXEC_PRESERVE_CONTEXT)
1003                         image->preserve_context = 1;
1004                 result = machine_kexec_prepare(image);
1005                 if (result)
1006                         goto out;
1007
1008                 for (i = 0; i < nr_segments; i++) {
1009                         result = kimage_load_segment(image, &image->segment[i]);
1010                         if (result)
1011                                 goto out;
1012                 }
1013                 kimage_terminate(image);
1014         }
1015         /* Install the new kernel, and  Uninstall the old */
1016         image = xchg(dest_image, image);
1017
1018 out:
1019         mutex_unlock(&kexec_mutex);
1020         kimage_free(image);
1021
1022         return result;
1023 }
1024
1025 #ifdef CONFIG_COMPAT
1026 asmlinkage long compat_sys_kexec_load(unsigned long entry,
1027                                 unsigned long nr_segments,
1028                                 struct compat_kexec_segment __user *segments,
1029                                 unsigned long flags)
1030 {
1031         struct compat_kexec_segment in;
1032         struct kexec_segment out, __user *ksegments;
1033         unsigned long i, result;
1034
1035         /* Don't allow clients that don't understand the native
1036          * architecture to do anything.
1037          */
1038         if ((flags & KEXEC_ARCH_MASK) == KEXEC_ARCH_DEFAULT)
1039                 return -EINVAL;
1040
1041         if (nr_segments > KEXEC_SEGMENT_MAX)
1042                 return -EINVAL;
1043
1044         ksegments = compat_alloc_user_space(nr_segments * sizeof(out));
1045         for (i=0; i < nr_segments; i++) {
1046                 result = copy_from_user(&in, &segments[i], sizeof(in));
1047                 if (result)
1048                         return -EFAULT;
1049
1050                 out.buf   = compat_ptr(in.buf);
1051                 out.bufsz = in.bufsz;
1052                 out.mem   = in.mem;
1053                 out.memsz = in.memsz;
1054
1055                 result = copy_to_user(&ksegments[i], &out, sizeof(out));
1056                 if (result)
1057                         return -EFAULT;
1058         }
1059
1060         return sys_kexec_load(entry, nr_segments, ksegments, flags);
1061 }
1062 #endif
1063
1064 void crash_kexec(struct pt_regs *regs)
1065 {
1066         /* Take the kexec_mutex here to prevent sys_kexec_load
1067          * running on one cpu from replacing the crash kernel
1068          * we are using after a panic on a different cpu.
1069          *
1070          * If the crash kernel was not located in a fixed area
1071          * of memory the xchg(&kexec_crash_image) would be
1072          * sufficient.  But since I reuse the memory...
1073          */
1074         if (mutex_trylock(&kexec_mutex)) {
1075                 if (kexec_crash_image) {
1076                         struct pt_regs fixed_regs;
1077                         crash_setup_regs(&fixed_regs, regs);
1078                         crash_save_vmcoreinfo();
1079                         machine_crash_shutdown(&fixed_regs);
1080                         machine_kexec(kexec_crash_image);
1081                 }
1082                 mutex_unlock(&kexec_mutex);
1083         }
1084 }
1085
1086 size_t crash_get_memory_size(void)
1087 {
1088         size_t size;
1089         mutex_lock(&kexec_mutex);
1090         size = crashk_res.end - crashk_res.start + 1;
1091         mutex_unlock(&kexec_mutex);
1092         return size;
1093 }
1094
1095 static void free_reserved_phys_range(unsigned long begin, unsigned long end)
1096 {
1097         unsigned long addr;
1098
1099         for (addr = begin; addr < end; addr += PAGE_SIZE) {
1100                 ClearPageReserved(pfn_to_page(addr >> PAGE_SHIFT));
1101                 init_page_count(pfn_to_page(addr >> PAGE_SHIFT));
1102                 free_page((unsigned long)__va(addr));
1103                 totalram_pages++;
1104         }
1105 }
1106
1107 int crash_shrink_memory(unsigned long new_size)
1108 {
1109         int ret = 0;
1110         unsigned long start, end;
1111
1112         mutex_lock(&kexec_mutex);
1113
1114         if (kexec_crash_image) {
1115                 ret = -ENOENT;
1116                 goto unlock;
1117         }
1118         start = crashk_res.start;
1119         end = crashk_res.end;
1120
1121         if (new_size >= end - start + 1) {
1122                 ret = -EINVAL;
1123                 if (new_size == end - start + 1)
1124                         ret = 0;
1125                 goto unlock;
1126         }
1127
1128         start = roundup(start, PAGE_SIZE);
1129         end = roundup(start + new_size, PAGE_SIZE);
1130
1131         free_reserved_phys_range(end, crashk_res.end);
1132
1133         if (start == end) {
1134                 crashk_res.end = end;
1135                 release_resource(&crashk_res);
1136         } else
1137                 crashk_res.end = end - 1;
1138
1139 unlock:
1140         mutex_unlock(&kexec_mutex);
1141         return ret;
1142 }
1143
1144 static u32 *append_elf_note(u32 *buf, char *name, unsigned type, void *data,
1145                             size_t data_len)
1146 {
1147         struct elf_note note;
1148
1149         note.n_namesz = strlen(name) + 1;
1150         note.n_descsz = data_len;
1151         note.n_type   = type;
1152         memcpy(buf, &note, sizeof(note));
1153         buf += (sizeof(note) + 3)/4;
1154         memcpy(buf, name, note.n_namesz);
1155         buf += (note.n_namesz + 3)/4;
1156         memcpy(buf, data, note.n_descsz);
1157         buf += (note.n_descsz + 3)/4;
1158
1159         return buf;
1160 }
1161
1162 static void final_note(u32 *buf)
1163 {
1164         struct elf_note note;
1165
1166         note.n_namesz = 0;
1167         note.n_descsz = 0;
1168         note.n_type   = 0;
1169         memcpy(buf, &note, sizeof(note));
1170 }
1171
1172 void crash_save_cpu(struct pt_regs *regs, int cpu)
1173 {
1174         struct elf_prstatus prstatus;
1175         u32 *buf;
1176
1177         if ((cpu < 0) || (cpu >= nr_cpu_ids))
1178                 return;
1179
1180         /* Using ELF notes here is opportunistic.
1181          * I need a well defined structure format
1182          * for the data I pass, and I need tags
1183          * on the data to indicate what information I have
1184          * squirrelled away.  ELF notes happen to provide
1185          * all of that, so there is no need to invent something new.
1186          */
1187         buf = (u32*)per_cpu_ptr(crash_notes, cpu);
1188         if (!buf)
1189                 return;
1190         memset(&prstatus, 0, sizeof(prstatus));
1191         prstatus.pr_pid = current->pid;
1192         elf_core_copy_kernel_regs(&prstatus.pr_reg, regs);
1193         buf = append_elf_note(buf, KEXEC_CORE_NOTE_NAME, NT_PRSTATUS,
1194                               &prstatus, sizeof(prstatus));
1195         final_note(buf);
1196 }
1197
1198 static int __init crash_notes_memory_init(void)
1199 {
1200         /* Allocate memory for saving cpu registers. */
1201         crash_notes = alloc_percpu(note_buf_t);
1202         if (!crash_notes) {
1203                 printk("Kexec: Memory allocation for saving cpu register"
1204                 " states failed\n");
1205                 return -ENOMEM;
1206         }
1207         return 0;
1208 }
1209 module_init(crash_notes_memory_init)
1210
1211
1212 /*
1213  * parsing the "crashkernel" commandline
1214  *
1215  * this code is intended to be called from architecture specific code
1216  */
1217
1218
1219 /*
1220  * This function parses command lines in the format
1221  *
1222  *   crashkernel=ramsize-range:size[,...][@offset]
1223  *
1224  * The function returns 0 on success and -EINVAL on failure.
1225  */
1226 static int __init parse_crashkernel_mem(char                    *cmdline,
1227                                         unsigned long long      system_ram,
1228                                         unsigned long long      *crash_size,
1229                                         unsigned long long      *crash_base)
1230 {
1231         char *cur = cmdline, *tmp;
1232
1233         /* for each entry of the comma-separated list */
1234         do {
1235                 unsigned long long start, end = ULLONG_MAX, size;
1236
1237                 /* get the start of the range */
1238                 start = memparse(cur, &tmp);
1239                 if (cur == tmp) {
1240                         pr_warning("crashkernel: Memory value expected\n");
1241                         return -EINVAL;
1242                 }
1243                 cur = tmp;
1244                 if (*cur != '-') {
1245                         pr_warning("crashkernel: '-' expected\n");
1246                         return -EINVAL;
1247                 }
1248                 cur++;
1249
1250                 /* if no ':' is here, than we read the end */
1251                 if (*cur != ':') {
1252                         end = memparse(cur, &tmp);
1253                         if (cur == tmp) {
1254                                 pr_warning("crashkernel: Memory "
1255                                                 "value expected\n");
1256                                 return -EINVAL;
1257                         }
1258                         cur = tmp;
1259                         if (end <= start) {
1260                                 pr_warning("crashkernel: end <= start\n");
1261                                 return -EINVAL;
1262                         }
1263                 }
1264
1265                 if (*cur != ':') {
1266                         pr_warning("crashkernel: ':' expected\n");
1267                         return -EINVAL;
1268                 }
1269                 cur++;
1270
1271                 size = memparse(cur, &tmp);
1272                 if (cur == tmp) {
1273                         pr_warning("Memory value expected\n");
1274                         return -EINVAL;
1275                 }
1276                 cur = tmp;
1277                 if (size >= system_ram) {
1278                         pr_warning("crashkernel: invalid size\n");
1279                         return -EINVAL;
1280                 }
1281
1282                 /* match ? */
1283                 if (system_ram >= start && system_ram < end) {
1284                         *crash_size = size;
1285                         break;
1286                 }
1287         } while (*cur++ == ',');
1288
1289         if (*crash_size > 0) {
1290                 while (*cur && *cur != ' ' && *cur != '@')
1291                         cur++;
1292                 if (*cur == '@') {
1293                         cur++;
1294                         *crash_base = memparse(cur, &tmp);
1295                         if (cur == tmp) {
1296                                 pr_warning("Memory value expected "
1297                                                 "after '@'\n");
1298                                 return -EINVAL;
1299                         }
1300                 }
1301         }
1302
1303         return 0;
1304 }
1305
1306 /*
1307  * That function parses "simple" (old) crashkernel command lines like
1308  *
1309  *      crashkernel=size[@offset]
1310  *
1311  * It returns 0 on success and -EINVAL on failure.
1312  */
1313 static int __init parse_crashkernel_simple(char                 *cmdline,
1314                                            unsigned long long   *crash_size,
1315                                            unsigned long long   *crash_base)
1316 {
1317         char *cur = cmdline;
1318
1319         *crash_size = memparse(cmdline, &cur);
1320         if (cmdline == cur) {
1321                 pr_warning("crashkernel: memory value expected\n");
1322                 return -EINVAL;
1323         }
1324
1325         if (*cur == '@')
1326                 *crash_base = memparse(cur+1, &cur);
1327
1328         return 0;
1329 }
1330
1331 /*
1332  * That function is the entry point for command line parsing and should be
1333  * called from the arch-specific code.
1334  */
1335 int __init parse_crashkernel(char                *cmdline,
1336                              unsigned long long system_ram,
1337                              unsigned long long *crash_size,
1338                              unsigned long long *crash_base)
1339 {
1340         char    *p = cmdline, *ck_cmdline = NULL;
1341         char    *first_colon, *first_space;
1342
1343         BUG_ON(!crash_size || !crash_base);
1344         *crash_size = 0;
1345         *crash_base = 0;
1346
1347         /* find crashkernel and use the last one if there are more */
1348         p = strstr(p, "crashkernel=");
1349         while (p) {
1350                 ck_cmdline = p;
1351                 p = strstr(p+1, "crashkernel=");
1352         }
1353
1354         if (!ck_cmdline)
1355                 return -EINVAL;
1356
1357         ck_cmdline += 12; /* strlen("crashkernel=") */
1358
1359         /*
1360          * if the commandline contains a ':', then that's the extended
1361          * syntax -- if not, it must be the classic syntax
1362          */
1363         first_colon = strchr(ck_cmdline, ':');
1364         first_space = strchr(ck_cmdline, ' ');
1365         if (first_colon && (!first_space || first_colon < first_space))
1366                 return parse_crashkernel_mem(ck_cmdline, system_ram,
1367                                 crash_size, crash_base);
1368         else
1369                 return parse_crashkernel_simple(ck_cmdline, crash_size,
1370                                 crash_base);
1371
1372         return 0;
1373 }
1374
1375
1376
1377 void crash_save_vmcoreinfo(void)
1378 {
1379         u32 *buf;
1380
1381         if (!vmcoreinfo_size)
1382                 return;
1383
1384         vmcoreinfo_append_str("CRASHTIME=%ld", get_seconds());
1385
1386         buf = (u32 *)vmcoreinfo_note;
1387
1388         buf = append_elf_note(buf, VMCOREINFO_NOTE_NAME, 0, vmcoreinfo_data,
1389                               vmcoreinfo_size);
1390
1391         final_note(buf);
1392 }
1393
1394 void vmcoreinfo_append_str(const char *fmt, ...)
1395 {
1396         va_list args;
1397         char buf[0x50];
1398         int r;
1399
1400         va_start(args, fmt);
1401         r = vsnprintf(buf, sizeof(buf), fmt, args);
1402         va_end(args);
1403
1404         if (r + vmcoreinfo_size > vmcoreinfo_max_size)
1405                 r = vmcoreinfo_max_size - vmcoreinfo_size;
1406
1407         memcpy(&vmcoreinfo_data[vmcoreinfo_size], buf, r);
1408
1409         vmcoreinfo_size += r;
1410 }
1411
1412 /*
1413  * provide an empty default implementation here -- architecture
1414  * code may override this
1415  */
1416 void __attribute__ ((weak)) arch_crash_save_vmcoreinfo(void)
1417 {}
1418
1419 unsigned long __attribute__ ((weak)) paddr_vmcoreinfo_note(void)
1420 {
1421         return __pa((unsigned long)(char *)&vmcoreinfo_note);
1422 }
1423
1424 static int __init crash_save_vmcoreinfo_init(void)
1425 {
1426         VMCOREINFO_OSRELEASE(init_uts_ns.name.release);
1427         VMCOREINFO_PAGESIZE(PAGE_SIZE);
1428
1429         VMCOREINFO_SYMBOL(init_uts_ns);
1430         VMCOREINFO_SYMBOL(node_online_map);
1431         VMCOREINFO_SYMBOL(swapper_pg_dir);
1432         VMCOREINFO_SYMBOL(_stext);
1433         VMCOREINFO_SYMBOL(vmlist);
1434
1435 #ifndef CONFIG_NEED_MULTIPLE_NODES
1436         VMCOREINFO_SYMBOL(mem_map);
1437         VMCOREINFO_SYMBOL(contig_page_data);
1438 #endif
1439 #ifdef CONFIG_SPARSEMEM
1440         VMCOREINFO_SYMBOL(mem_section);
1441         VMCOREINFO_LENGTH(mem_section, NR_SECTION_ROOTS);
1442         VMCOREINFO_STRUCT_SIZE(mem_section);
1443         VMCOREINFO_OFFSET(mem_section, section_mem_map);
1444 #endif
1445         VMCOREINFO_STRUCT_SIZE(page);
1446         VMCOREINFO_STRUCT_SIZE(pglist_data);
1447         VMCOREINFO_STRUCT_SIZE(zone);
1448         VMCOREINFO_STRUCT_SIZE(free_area);
1449         VMCOREINFO_STRUCT_SIZE(list_head);
1450         VMCOREINFO_SIZE(nodemask_t);
1451         VMCOREINFO_OFFSET(page, flags);
1452         VMCOREINFO_OFFSET(page, _count);
1453         VMCOREINFO_OFFSET(page, mapping);
1454         VMCOREINFO_OFFSET(page, lru);
1455         VMCOREINFO_OFFSET(pglist_data, node_zones);
1456         VMCOREINFO_OFFSET(pglist_data, nr_zones);
1457 #ifdef CONFIG_FLAT_NODE_MEM_MAP
1458         VMCOREINFO_OFFSET(pglist_data, node_mem_map);
1459 #endif
1460         VMCOREINFO_OFFSET(pglist_data, node_start_pfn);
1461         VMCOREINFO_OFFSET(pglist_data, node_spanned_pages);
1462         VMCOREINFO_OFFSET(pglist_data, node_id);
1463         VMCOREINFO_OFFSET(zone, free_area);
1464         VMCOREINFO_OFFSET(zone, vm_stat);
1465         VMCOREINFO_OFFSET(zone, spanned_pages);
1466         VMCOREINFO_OFFSET(free_area, free_list);
1467         VMCOREINFO_OFFSET(list_head, next);
1468         VMCOREINFO_OFFSET(list_head, prev);
1469         VMCOREINFO_OFFSET(vm_struct, addr);
1470         VMCOREINFO_LENGTH(zone.free_area, MAX_ORDER);
1471         log_buf_kexec_setup();
1472         VMCOREINFO_LENGTH(free_area.free_list, MIGRATE_TYPES);
1473         VMCOREINFO_NUMBER(NR_FREE_PAGES);
1474         VMCOREINFO_NUMBER(PG_lru);
1475         VMCOREINFO_NUMBER(PG_private);
1476         VMCOREINFO_NUMBER(PG_swapcache);
1477
1478         arch_crash_save_vmcoreinfo();
1479
1480         return 0;
1481 }
1482
1483 module_init(crash_save_vmcoreinfo_init)
1484
1485 /*
1486  * Move into place and start executing a preloaded standalone
1487  * executable.  If nothing was preloaded return an error.
1488  */
1489 int kernel_kexec(void)
1490 {
1491         int error = 0;
1492
1493         if (!mutex_trylock(&kexec_mutex))
1494                 return -EBUSY;
1495         if (!kexec_image) {
1496                 error = -EINVAL;
1497                 goto Unlock;
1498         }
1499
1500 #ifdef CONFIG_KEXEC_JUMP
1501         if (kexec_image->preserve_context) {
1502                 mutex_lock(&pm_mutex);
1503                 pm_prepare_console();
1504                 error = freeze_processes();
1505                 if (error) {
1506                         error = -EBUSY;
1507                         goto Restore_console;
1508                 }
1509                 suspend_console();
1510                 error = dpm_suspend_start(PMSG_FREEZE);
1511                 if (error)
1512                         goto Resume_console;
1513                 /* At this point, dpm_suspend_start() has been called,
1514                  * but *not* dpm_suspend_noirq(). We *must* call
1515                  * dpm_suspend_noirq() now.  Otherwise, drivers for
1516                  * some devices (e.g. interrupt controllers) become
1517                  * desynchronized with the actual state of the
1518                  * hardware at resume time, and evil weirdness ensues.
1519                  */
1520                 error = dpm_suspend_noirq(PMSG_FREEZE);
1521                 if (error)
1522                         goto Resume_devices;
1523                 error = disable_nonboot_cpus();
1524                 if (error)
1525                         goto Enable_cpus;
1526                 local_irq_disable();
1527                 /* Suspend system devices */
1528                 error = sysdev_suspend(PMSG_FREEZE);
1529                 if (error)
1530                         goto Enable_irqs;
1531         } else
1532 #endif
1533         {
1534                 kernel_restart_prepare(NULL);
1535                 printk(KERN_EMERG "Starting new kernel\n");
1536                 machine_shutdown();
1537         }
1538
1539         machine_kexec(kexec_image);
1540
1541 #ifdef CONFIG_KEXEC_JUMP
1542         if (kexec_image->preserve_context) {
1543                 sysdev_resume();
1544  Enable_irqs:
1545                 local_irq_enable();
1546  Enable_cpus:
1547                 enable_nonboot_cpus();
1548                 dpm_resume_noirq(PMSG_RESTORE);
1549  Resume_devices:
1550                 dpm_resume_end(PMSG_RESTORE);
1551  Resume_console:
1552                 resume_console();
1553                 thaw_processes();
1554  Restore_console:
1555                 pm_restore_console();
1556                 mutex_unlock(&pm_mutex);
1557         }
1558 #endif
1559
1560  Unlock:
1561         mutex_unlock(&kexec_mutex);
1562         return error;
1563 }