Root/kernel/power/snapshot.c

1/*
2 * linux/kernel/power/snapshot.c
3 *
4 * This file provides system snapshot/restore functionality for swsusp.
5 *
6 * Copyright (C) 1998-2005 Pavel Machek <pavel@ucw.cz>
7 * Copyright (C) 2006 Rafael J. Wysocki <rjw@sisk.pl>
8 *
9 * This file is released under the GPLv2.
10 *
11 */
12
13#include <linux/version.h>
14#include <linux/module.h>
15#include <linux/mm.h>
16#include <linux/suspend.h>
17#include <linux/delay.h>
18#include <linux/bitops.h>
19#include <linux/spinlock.h>
20#include <linux/kernel.h>
21#include <linux/pm.h>
22#include <linux/device.h>
23#include <linux/init.h>
24#include <linux/bootmem.h>
25#include <linux/syscalls.h>
26#include <linux/console.h>
27#include <linux/highmem.h>
28#include <linux/list.h>
29#include <linux/slab.h>
30
31#include <asm/uaccess.h>
32#include <asm/mmu_context.h>
33#include <asm/pgtable.h>
34#include <asm/tlbflush.h>
35#include <asm/io.h>
36
37#include "power.h"
38
39static int swsusp_page_is_free(struct page *);
40static void swsusp_set_page_forbidden(struct page *);
41static void swsusp_unset_page_forbidden(struct page *);
42
43/*
44 * Number of bytes to reserve for memory allocations made by device drivers
45 * from their ->freeze() and ->freeze_noirq() callbacks so that they don't
46 * cause image creation to fail (tunable via /sys/power/reserved_size).
47 */
48unsigned long reserved_size;
49
50void __init hibernate_reserved_size_init(void)
51{
52    reserved_size = SPARE_PAGES * PAGE_SIZE;
53}
54
55/*
56 * Preferred image size in bytes (tunable via /sys/power/image_size).
57 * When it is set to N, swsusp will do its best to ensure the image
58 * size will not exceed N bytes, but if that is impossible, it will
59 * try to create the smallest image possible.
60 */
61unsigned long image_size;
62
63void __init hibernate_image_size_init(void)
64{
65    image_size = ((totalram_pages * 2) / 5) * PAGE_SIZE;
66}
67
68/* List of PBEs needed for restoring the pages that were allocated before
69 * the suspend and included in the suspend image, but have also been
70 * allocated by the "resume" kernel, so their contents cannot be written
71 * directly to their "original" page frames.
72 */
73struct pbe *restore_pblist;
74
75/* Pointer to an auxiliary buffer (1 page) */
76static void *buffer;
77
78/**
79 * @safe_needed - on resume, for storing the PBE list and the image,
80 * we can only use memory pages that do not conflict with the pages
81 * used before suspend. The unsafe pages have PageNosaveFree set
82 * and we count them using unsafe_pages.
83 *
84 * Each allocated image page is marked as PageNosave and PageNosaveFree
85 * so that swsusp_free() can release it.
86 */
87
88#define PG_ANY 0
89#define PG_SAFE 1
90#define PG_UNSAFE_CLEAR 1
91#define PG_UNSAFE_KEEP 0
92
93static unsigned int allocated_unsafe_pages;
94
95static void *get_image_page(gfp_t gfp_mask, int safe_needed)
96{
97    void *res;
98
99    res = (void *)get_zeroed_page(gfp_mask);
100    if (safe_needed)
101        while (res && swsusp_page_is_free(virt_to_page(res))) {
102            /* The page is unsafe, mark it for swsusp_free() */
103            swsusp_set_page_forbidden(virt_to_page(res));
104            allocated_unsafe_pages++;
105            res = (void *)get_zeroed_page(gfp_mask);
106        }
107    if (res) {
108        swsusp_set_page_forbidden(virt_to_page(res));
109        swsusp_set_page_free(virt_to_page(res));
110    }
111    return res;
112}
113
114unsigned long get_safe_page(gfp_t gfp_mask)
115{
116    return (unsigned long)get_image_page(gfp_mask, PG_SAFE);
117}
118
119static struct page *alloc_image_page(gfp_t gfp_mask)
120{
121    struct page *page;
122
123    page = alloc_page(gfp_mask);
124    if (page) {
125        swsusp_set_page_forbidden(page);
126        swsusp_set_page_free(page);
127    }
128    return page;
129}
130
131/**
132 * free_image_page - free page represented by @addr, allocated with
133 * get_image_page (page flags set by it must be cleared)
134 */
135
136static inline void free_image_page(void *addr, int clear_nosave_free)
137{
138    struct page *page;
139
140    BUG_ON(!virt_addr_valid(addr));
141
142    page = virt_to_page(addr);
143
144    swsusp_unset_page_forbidden(page);
145    if (clear_nosave_free)
146        swsusp_unset_page_free(page);
147
148    __free_page(page);
149}
150
151/* struct linked_page is used to build chains of pages */
152
153#define LINKED_PAGE_DATA_SIZE (PAGE_SIZE - sizeof(void *))
154
155struct linked_page {
156    struct linked_page *next;
157    char data[LINKED_PAGE_DATA_SIZE];
158} __attribute__((packed));
159
160static inline void
161free_list_of_pages(struct linked_page *list, int clear_page_nosave)
162{
163    while (list) {
164        struct linked_page *lp = list->next;
165
166        free_image_page(list, clear_page_nosave);
167        list = lp;
168    }
169}
170
171/**
172  * struct chain_allocator is used for allocating small objects out of
173  * a linked list of pages called 'the chain'.
174  *
175  * The chain grows each time when there is no room for a new object in
176  * the current page. The allocated objects cannot be freed individually.
177  * It is only possible to free them all at once, by freeing the entire
178  * chain.
179  *
180  * NOTE: The chain allocator may be inefficient if the allocated objects
181  * are not much smaller than PAGE_SIZE.
182  */
183
184struct chain_allocator {
185    struct linked_page *chain; /* the chain */
186    unsigned int used_space; /* total size of objects allocated out
187                     * of the current page
188                     */
189    gfp_t gfp_mask; /* mask for allocating pages */
190    int safe_needed; /* if set, only "safe" pages are allocated */
191};
192
193static void
194chain_init(struct chain_allocator *ca, gfp_t gfp_mask, int safe_needed)
195{
196    ca->chain = NULL;
197    ca->used_space = LINKED_PAGE_DATA_SIZE;
198    ca->gfp_mask = gfp_mask;
199    ca->safe_needed = safe_needed;
200}
201
202static void *chain_alloc(struct chain_allocator *ca, unsigned int size)
203{
204    void *ret;
205
206    if (LINKED_PAGE_DATA_SIZE - ca->used_space < size) {
207        struct linked_page *lp;
208
209        lp = get_image_page(ca->gfp_mask, ca->safe_needed);
210        if (!lp)
211            return NULL;
212
213        lp->next = ca->chain;
214        ca->chain = lp;
215        ca->used_space = 0;
216    }
217    ret = ca->chain->data + ca->used_space;
218    ca->used_space += size;
219    return ret;
220}
221
222/**
223 * Data types related to memory bitmaps.
224 *
225 * Memory bitmap is a structure consiting of many linked lists of
226 * objects. The main list's elements are of type struct zone_bitmap
227 * and each of them corresonds to one zone. For each zone bitmap
228 * object there is a list of objects of type struct bm_block that
229 * represent each blocks of bitmap in which information is stored.
230 *
231 * struct memory_bitmap contains a pointer to the main list of zone
232 * bitmap objects, a struct bm_position used for browsing the bitmap,
233 * and a pointer to the list of pages used for allocating all of the
234 * zone bitmap objects and bitmap block objects.
235 *
236 * NOTE: It has to be possible to lay out the bitmap in memory
237 * using only allocations of order 0. Additionally, the bitmap is
238 * designed to work with arbitrary number of zones (this is over the
239 * top for now, but let's avoid making unnecessary assumptions ;-).
240 *
241 * struct zone_bitmap contains a pointer to a list of bitmap block
242 * objects and a pointer to the bitmap block object that has been
243 * most recently used for setting bits. Additionally, it contains the
244 * pfns that correspond to the start and end of the represented zone.
245 *
246 * struct bm_block contains a pointer to the memory page in which
247 * information is stored (in the form of a block of bitmap)
248 * It also contains the pfns that correspond to the start and end of
249 * the represented memory area.
250 */
251
252#define BM_END_OF_MAP (~0UL)
253
254#define BM_BITS_PER_BLOCK (PAGE_SIZE * BITS_PER_BYTE)
255
256struct bm_block {
257    struct list_head hook; /* hook into a list of bitmap blocks */
258    unsigned long start_pfn; /* pfn represented by the first bit */
259    unsigned long end_pfn; /* pfn represented by the last bit plus 1 */
260    unsigned long *data; /* bitmap representing pages */
261};
262
263static inline unsigned long bm_block_bits(struct bm_block *bb)
264{
265    return bb->end_pfn - bb->start_pfn;
266}
267
268/* strcut bm_position is used for browsing memory bitmaps */
269
270struct bm_position {
271    struct bm_block *block;
272    int bit;
273};
274
275struct memory_bitmap {
276    struct list_head blocks; /* list of bitmap blocks */
277    struct linked_page *p_list; /* list of pages used to store zone
278                     * bitmap objects and bitmap block
279                     * objects
280                     */
281    struct bm_position cur; /* most recently used bit position */
282};
283
284/* Functions that operate on memory bitmaps */
285
286static void memory_bm_position_reset(struct memory_bitmap *bm)
287{
288    bm->cur.block = list_entry(bm->blocks.next, struct bm_block, hook);
289    bm->cur.bit = 0;
290}
291
292static void memory_bm_free(struct memory_bitmap *bm, int clear_nosave_free);
293
294/**
295 * create_bm_block_list - create a list of block bitmap objects
296 * @pages - number of pages to track
297 * @list - list to put the allocated blocks into
298 * @ca - chain allocator to be used for allocating memory
299 */
300static int create_bm_block_list(unsigned long pages,
301                struct list_head *list,
302                struct chain_allocator *ca)
303{
304    unsigned int nr_blocks = DIV_ROUND_UP(pages, BM_BITS_PER_BLOCK);
305
306    while (nr_blocks-- > 0) {
307        struct bm_block *bb;
308
309        bb = chain_alloc(ca, sizeof(struct bm_block));
310        if (!bb)
311            return -ENOMEM;
312        list_add(&bb->hook, list);
313    }
314
315    return 0;
316}
317
318struct mem_extent {
319    struct list_head hook;
320    unsigned long start;
321    unsigned long end;
322};
323
324/**
325 * free_mem_extents - free a list of memory extents
326 * @list - list of extents to empty
327 */
328static void free_mem_extents(struct list_head *list)
329{
330    struct mem_extent *ext, *aux;
331
332    list_for_each_entry_safe(ext, aux, list, hook) {
333        list_del(&ext->hook);
334        kfree(ext);
335    }
336}
337
338/**
339 * create_mem_extents - create a list of memory extents representing
340 * contiguous ranges of PFNs
341 * @list - list to put the extents into
342 * @gfp_mask - mask to use for memory allocations
343 */
344static int create_mem_extents(struct list_head *list, gfp_t gfp_mask)
345{
346    struct zone *zone;
347
348    INIT_LIST_HEAD(list);
349
350    for_each_populated_zone(zone) {
351        unsigned long zone_start, zone_end;
352        struct mem_extent *ext, *cur, *aux;
353
354        zone_start = zone->zone_start_pfn;
355        zone_end = zone->zone_start_pfn + zone->spanned_pages;
356
357        list_for_each_entry(ext, list, hook)
358            if (zone_start <= ext->end)
359                break;
360
361        if (&ext->hook == list || zone_end < ext->start) {
362            /* New extent is necessary */
363            struct mem_extent *new_ext;
364
365            new_ext = kzalloc(sizeof(struct mem_extent), gfp_mask);
366            if (!new_ext) {
367                free_mem_extents(list);
368                return -ENOMEM;
369            }
370            new_ext->start = zone_start;
371            new_ext->end = zone_end;
372            list_add_tail(&new_ext->hook, &ext->hook);
373            continue;
374        }
375
376        /* Merge this zone's range of PFNs with the existing one */
377        if (zone_start < ext->start)
378            ext->start = zone_start;
379        if (zone_end > ext->end)
380            ext->end = zone_end;
381
382        /* More merging may be possible */
383        cur = ext;
384        list_for_each_entry_safe_continue(cur, aux, list, hook) {
385            if (zone_end < cur->start)
386                break;
387            if (zone_end < cur->end)
388                ext->end = cur->end;
389            list_del(&cur->hook);
390            kfree(cur);
391        }
392    }
393
394    return 0;
395}
396
397/**
398  * memory_bm_create - allocate memory for a memory bitmap
399  */
400static int
401memory_bm_create(struct memory_bitmap *bm, gfp_t gfp_mask, int safe_needed)
402{
403    struct chain_allocator ca;
404    struct list_head mem_extents;
405    struct mem_extent *ext;
406    int error;
407
408    chain_init(&ca, gfp_mask, safe_needed);
409    INIT_LIST_HEAD(&bm->blocks);
410
411    error = create_mem_extents(&mem_extents, gfp_mask);
412    if (error)
413        return error;
414
415    list_for_each_entry(ext, &mem_extents, hook) {
416        struct bm_block *bb;
417        unsigned long pfn = ext->start;
418        unsigned long pages = ext->end - ext->start;
419
420        bb = list_entry(bm->blocks.prev, struct bm_block, hook);
421
422        error = create_bm_block_list(pages, bm->blocks.prev, &ca);
423        if (error)
424            goto Error;
425
426        list_for_each_entry_continue(bb, &bm->blocks, hook) {
427            bb->data = get_image_page(gfp_mask, safe_needed);
428            if (!bb->data) {
429                error = -ENOMEM;
430                goto Error;
431            }
432
433            bb->start_pfn = pfn;
434            if (pages >= BM_BITS_PER_BLOCK) {
435                pfn += BM_BITS_PER_BLOCK;
436                pages -= BM_BITS_PER_BLOCK;
437            } else {
438                /* This is executed only once in the loop */
439                pfn += pages;
440            }
441            bb->end_pfn = pfn;
442        }
443    }
444
445    bm->p_list = ca.chain;
446    memory_bm_position_reset(bm);
447 Exit:
448    free_mem_extents(&mem_extents);
449    return error;
450
451 Error:
452    bm->p_list = ca.chain;
453    memory_bm_free(bm, PG_UNSAFE_CLEAR);
454    goto Exit;
455}
456
457/**
458  * memory_bm_free - free memory occupied by the memory bitmap @bm
459  */
460static void memory_bm_free(struct memory_bitmap *bm, int clear_nosave_free)
461{
462    struct bm_block *bb;
463
464    list_for_each_entry(bb, &bm->blocks, hook)
465        if (bb->data)
466            free_image_page(bb->data, clear_nosave_free);
467
468    free_list_of_pages(bm->p_list, clear_nosave_free);
469
470    INIT_LIST_HEAD(&bm->blocks);
471}
472
473/**
474 * memory_bm_find_bit - find the bit in the bitmap @bm that corresponds
475 * to given pfn. The cur_zone_bm member of @bm and the cur_block member
476 * of @bm->cur_zone_bm are updated.
477 */
478static int memory_bm_find_bit(struct memory_bitmap *bm, unsigned long pfn,
479                void **addr, unsigned int *bit_nr)
480{
481    struct bm_block *bb;
482
483    /*
484     * Check if the pfn corresponds to the current bitmap block and find
485     * the block where it fits if this is not the case.
486     */
487    bb = bm->cur.block;
488    if (pfn < bb->start_pfn)
489        list_for_each_entry_continue_reverse(bb, &bm->blocks, hook)
490            if (pfn >= bb->start_pfn)
491                break;
492
493    if (pfn >= bb->end_pfn)
494        list_for_each_entry_continue(bb, &bm->blocks, hook)
495            if (pfn >= bb->start_pfn && pfn < bb->end_pfn)
496                break;
497
498    if (&bb->hook == &bm->blocks)
499        return -EFAULT;
500
501    /* The block has been found */
502    bm->cur.block = bb;
503    pfn -= bb->start_pfn;
504    bm->cur.bit = pfn + 1;
505    *bit_nr = pfn;
506    *addr = bb->data;
507    return 0;
508}
509
510static void memory_bm_set_bit(struct memory_bitmap *bm, unsigned long pfn)
511{
512    void *addr;
513    unsigned int bit;
514    int error;
515
516    error = memory_bm_find_bit(bm, pfn, &addr, &bit);
517    BUG_ON(error);
518    set_bit(bit, addr);
519}
520
521static int mem_bm_set_bit_check(struct memory_bitmap *bm, unsigned long pfn)
522{
523    void *addr;
524    unsigned int bit;
525    int error;
526
527    error = memory_bm_find_bit(bm, pfn, &addr, &bit);
528    if (!error)
529        set_bit(bit, addr);
530    return error;
531}
532
533static void memory_bm_clear_bit(struct memory_bitmap *bm, unsigned long pfn)
534{
535    void *addr;
536    unsigned int bit;
537    int error;
538
539    error = memory_bm_find_bit(bm, pfn, &addr, &bit);
540    BUG_ON(error);
541    clear_bit(bit, addr);
542}
543
544static int memory_bm_test_bit(struct memory_bitmap *bm, unsigned long pfn)
545{
546    void *addr;
547    unsigned int bit;
548    int error;
549
550    error = memory_bm_find_bit(bm, pfn, &addr, &bit);
551    BUG_ON(error);
552    return test_bit(bit, addr);
553}
554
555static bool memory_bm_pfn_present(struct memory_bitmap *bm, unsigned long pfn)
556{
557    void *addr;
558    unsigned int bit;
559
560    return !memory_bm_find_bit(bm, pfn, &addr, &bit);
561}
562
563/**
564 * memory_bm_next_pfn - find the pfn that corresponds to the next set bit
565 * in the bitmap @bm. If the pfn cannot be found, BM_END_OF_MAP is
566 * returned.
567 *
568 * It is required to run memory_bm_position_reset() before the first call to
569 * this function.
570 */
571
572static unsigned long memory_bm_next_pfn(struct memory_bitmap *bm)
573{
574    struct bm_block *bb;
575    int bit;
576
577    bb = bm->cur.block;
578    do {
579        bit = bm->cur.bit;
580        bit = find_next_bit(bb->data, bm_block_bits(bb), bit);
581        if (bit < bm_block_bits(bb))
582            goto Return_pfn;
583
584        bb = list_entry(bb->hook.next, struct bm_block, hook);
585        bm->cur.block = bb;
586        bm->cur.bit = 0;
587    } while (&bb->hook != &bm->blocks);
588
589    memory_bm_position_reset(bm);
590    return BM_END_OF_MAP;
591
592 Return_pfn:
593    bm->cur.bit = bit + 1;
594    return bb->start_pfn + bit;
595}
596
597/**
598 * This structure represents a range of page frames the contents of which
599 * should not be saved during the suspend.
600 */
601
602struct nosave_region {
603    struct list_head list;
604    unsigned long start_pfn;
605    unsigned long end_pfn;
606};
607
608static LIST_HEAD(nosave_regions);
609
610/**
611 * register_nosave_region - register a range of page frames the contents
612 * of which should not be saved during the suspend (to be used in the early
613 * initialization code)
614 */
615
616void __init
617__register_nosave_region(unsigned long start_pfn, unsigned long end_pfn,
618             int use_kmalloc)
619{
620    struct nosave_region *region;
621
622    if (start_pfn >= end_pfn)
623        return;
624
625    if (!list_empty(&nosave_regions)) {
626        /* Try to extend the previous region (they should be sorted) */
627        region = list_entry(nosave_regions.prev,
628                    struct nosave_region, list);
629        if (region->end_pfn == start_pfn) {
630            region->end_pfn = end_pfn;
631            goto Report;
632        }
633    }
634    if (use_kmalloc) {
635        /* during init, this shouldn't fail */
636        region = kmalloc(sizeof(struct nosave_region), GFP_KERNEL);
637        BUG_ON(!region);
638    } else
639        /* This allocation cannot fail */
640        region = alloc_bootmem(sizeof(struct nosave_region));
641    region->start_pfn = start_pfn;
642    region->end_pfn = end_pfn;
643    list_add_tail(&region->list, &nosave_regions);
644 Report:
645    printk(KERN_INFO "PM: Registered nosave memory: %016lx - %016lx\n",
646        start_pfn << PAGE_SHIFT, end_pfn << PAGE_SHIFT);
647}
648
649/*
650 * Set bits in this map correspond to the page frames the contents of which
651 * should not be saved during the suspend.
652 */
653static struct memory_bitmap *forbidden_pages_map;
654
655/* Set bits in this map correspond to free page frames. */
656static struct memory_bitmap *free_pages_map;
657
658/*
659 * Each page frame allocated for creating the image is marked by setting the
660 * corresponding bits in forbidden_pages_map and free_pages_map simultaneously
661 */
662
663void swsusp_set_page_free(struct page *page)
664{
665    if (free_pages_map)
666        memory_bm_set_bit(free_pages_map, page_to_pfn(page));
667}
668
669static int swsusp_page_is_free(struct page *page)
670{
671    return free_pages_map ?
672        memory_bm_test_bit(free_pages_map, page_to_pfn(page)) : 0;
673}
674
675void swsusp_unset_page_free(struct page *page)
676{
677    if (free_pages_map)
678        memory_bm_clear_bit(free_pages_map, page_to_pfn(page));
679}
680
681static void swsusp_set_page_forbidden(struct page *page)
682{
683    if (forbidden_pages_map)
684        memory_bm_set_bit(forbidden_pages_map, page_to_pfn(page));
685}
686
687int swsusp_page_is_forbidden(struct page *page)
688{
689    return forbidden_pages_map ?
690        memory_bm_test_bit(forbidden_pages_map, page_to_pfn(page)) : 0;
691}
692
693static void swsusp_unset_page_forbidden(struct page *page)
694{
695    if (forbidden_pages_map)
696        memory_bm_clear_bit(forbidden_pages_map, page_to_pfn(page));
697}
698
699/**
700 * mark_nosave_pages - set bits corresponding to the page frames the
701 * contents of which should not be saved in a given bitmap.
702 */
703
704static void mark_nosave_pages(struct memory_bitmap *bm)
705{
706    struct nosave_region *region;
707
708    if (list_empty(&nosave_regions))
709        return;
710
711    list_for_each_entry(region, &nosave_regions, list) {
712        unsigned long pfn;
713
714        pr_debug("PM: Marking nosave pages: %016lx - %016lx\n",
715                region->start_pfn << PAGE_SHIFT,
716                region->end_pfn << PAGE_SHIFT);
717
718        for (pfn = region->start_pfn; pfn < region->end_pfn; pfn++)
719            if (pfn_valid(pfn)) {
720                /*
721                 * It is safe to ignore the result of
722                 * mem_bm_set_bit_check() here, since we won't
723                 * touch the PFNs for which the error is
724                 * returned anyway.
725                 */
726                mem_bm_set_bit_check(bm, pfn);
727            }
728    }
729}
730
731/**
732 * create_basic_memory_bitmaps - create bitmaps needed for marking page
733 * frames that should not be saved and free page frames. The pointers
734 * forbidden_pages_map and free_pages_map are only modified if everything
735 * goes well, because we don't want the bits to be used before both bitmaps
736 * are set up.
737 */
738
739int create_basic_memory_bitmaps(void)
740{
741    struct memory_bitmap *bm1, *bm2;
742    int error = 0;
743
744    BUG_ON(forbidden_pages_map || free_pages_map);
745
746    bm1 = kzalloc(sizeof(struct memory_bitmap), GFP_KERNEL);
747    if (!bm1)
748        return -ENOMEM;
749
750    error = memory_bm_create(bm1, GFP_KERNEL, PG_ANY);
751    if (error)
752        goto Free_first_object;
753
754    bm2 = kzalloc(sizeof(struct memory_bitmap), GFP_KERNEL);
755    if (!bm2)
756        goto Free_first_bitmap;
757
758    error = memory_bm_create(bm2, GFP_KERNEL, PG_ANY);
759    if (error)
760        goto Free_second_object;
761
762    forbidden_pages_map = bm1;
763    free_pages_map = bm2;
764    mark_nosave_pages(forbidden_pages_map);
765
766    pr_debug("PM: Basic memory bitmaps created\n");
767
768    return 0;
769
770 Free_second_object:
771    kfree(bm2);
772 Free_first_bitmap:
773     memory_bm_free(bm1, PG_UNSAFE_CLEAR);
774 Free_first_object:
775    kfree(bm1);
776    return -ENOMEM;
777}
778
779/**
780 * free_basic_memory_bitmaps - free memory bitmaps allocated by
781 * create_basic_memory_bitmaps(). The auxiliary pointers are necessary
782 * so that the bitmaps themselves are not referred to while they are being
783 * freed.
784 */
785
786void free_basic_memory_bitmaps(void)
787{
788    struct memory_bitmap *bm1, *bm2;
789
790    BUG_ON(!(forbidden_pages_map && free_pages_map));
791
792    bm1 = forbidden_pages_map;
793    bm2 = free_pages_map;
794    forbidden_pages_map = NULL;
795    free_pages_map = NULL;
796    memory_bm_free(bm1, PG_UNSAFE_CLEAR);
797    kfree(bm1);
798    memory_bm_free(bm2, PG_UNSAFE_CLEAR);
799    kfree(bm2);
800
801    pr_debug("PM: Basic memory bitmaps freed\n");
802}
803
804/**
805 * snapshot_additional_pages - estimate the number of additional pages
806 * be needed for setting up the suspend image data structures for given
807 * zone (usually the returned value is greater than the exact number)
808 */
809
810unsigned int snapshot_additional_pages(struct zone *zone)
811{
812    unsigned int res;
813
814    res = DIV_ROUND_UP(zone->spanned_pages, BM_BITS_PER_BLOCK);
815    res += DIV_ROUND_UP(res * sizeof(struct bm_block), PAGE_SIZE);
816    return 2 * res;
817}
818
819#ifdef CONFIG_HIGHMEM
820/**
821 * count_free_highmem_pages - compute the total number of free highmem
822 * pages, system-wide.
823 */
824
825static unsigned int count_free_highmem_pages(void)
826{
827    struct zone *zone;
828    unsigned int cnt = 0;
829
830    for_each_populated_zone(zone)
831        if (is_highmem(zone))
832            cnt += zone_page_state(zone, NR_FREE_PAGES);
833
834    return cnt;
835}
836
837/**
838 * saveable_highmem_page - Determine whether a highmem page should be
839 * included in the suspend image.
840 *
841 * We should save the page if it isn't Nosave or NosaveFree, or Reserved,
842 * and it isn't a part of a free chunk of pages.
843 */
844static struct page *saveable_highmem_page(struct zone *zone, unsigned long pfn)
845{
846    struct page *page;
847
848    if (!pfn_valid(pfn))
849        return NULL;
850
851    page = pfn_to_page(pfn);
852    if (page_zone(page) != zone)
853        return NULL;
854
855    BUG_ON(!PageHighMem(page));
856
857    if (swsusp_page_is_forbidden(page) || swsusp_page_is_free(page) ||
858        PageReserved(page))
859        return NULL;
860
861    return page;
862}
863
864/**
865 * count_highmem_pages - compute the total number of saveable highmem
866 * pages.
867 */
868
869static unsigned int count_highmem_pages(void)
870{
871    struct zone *zone;
872    unsigned int n = 0;
873
874    for_each_populated_zone(zone) {
875        unsigned long pfn, max_zone_pfn;
876
877        if (!is_highmem(zone))
878            continue;
879
880        mark_free_pages(zone);
881        max_zone_pfn = zone->zone_start_pfn + zone->spanned_pages;
882        for (pfn = zone->zone_start_pfn; pfn < max_zone_pfn; pfn++)
883            if (saveable_highmem_page(zone, pfn))
884                n++;
885    }
886    return n;
887}
888#else
889static inline void *saveable_highmem_page(struct zone *z, unsigned long p)
890{
891    return NULL;
892}
893#endif /* CONFIG_HIGHMEM */
894
895/**
896 * saveable_page - Determine whether a non-highmem page should be included
897 * in the suspend image.
898 *
899 * We should save the page if it isn't Nosave, and is not in the range
900 * of pages statically defined as 'unsaveable', and it isn't a part of
901 * a free chunk of pages.
902 */
903static struct page *saveable_page(struct zone *zone, unsigned long pfn)
904{
905    struct page *page;
906
907    if (!pfn_valid(pfn))
908        return NULL;
909
910    page = pfn_to_page(pfn);
911    if (page_zone(page) != zone)
912        return NULL;
913
914    BUG_ON(PageHighMem(page));
915
916    if (swsusp_page_is_forbidden(page) || swsusp_page_is_free(page))
917        return NULL;
918
919    if (PageReserved(page)
920        && (!kernel_page_present(page) || pfn_is_nosave(pfn)))
921        return NULL;
922
923    return page;
924}
925
926/**
927 * count_data_pages - compute the total number of saveable non-highmem
928 * pages.
929 */
930
931static unsigned int count_data_pages(void)
932{
933    struct zone *zone;
934    unsigned long pfn, max_zone_pfn;
935    unsigned int n = 0;
936
937    for_each_populated_zone(zone) {
938        if (is_highmem(zone))
939            continue;
940
941        mark_free_pages(zone);
942        max_zone_pfn = zone->zone_start_pfn + zone->spanned_pages;
943        for (pfn = zone->zone_start_pfn; pfn < max_zone_pfn; pfn++)
944            if (saveable_page(zone, pfn))
945                n++;
946    }
947    return n;
948}
949
950/* This is needed, because copy_page and memcpy are not usable for copying
951 * task structs.
952 */
953static inline void do_copy_page(long *dst, long *src)
954{
955    int n;
956
957    for (n = PAGE_SIZE / sizeof(long); n; n--)
958        *dst++ = *src++;
959}
960
961
962/**
963 * safe_copy_page - check if the page we are going to copy is marked as
964 * present in the kernel page tables (this always is the case if
965 * CONFIG_DEBUG_PAGEALLOC is not set and in that case
966 * kernel_page_present() always returns 'true').
967 */
968static void safe_copy_page(void *dst, struct page *s_page)
969{
970    if (kernel_page_present(s_page)) {
971        do_copy_page(dst, page_address(s_page));
972    } else {
973        kernel_map_pages(s_page, 1, 1);
974        do_copy_page(dst, page_address(s_page));
975        kernel_map_pages(s_page, 1, 0);
976    }
977}
978
979
980#ifdef CONFIG_HIGHMEM
981static inline struct page *
982page_is_saveable(struct zone *zone, unsigned long pfn)
983{
984    return is_highmem(zone) ?
985        saveable_highmem_page(zone, pfn) : saveable_page(zone, pfn);
986}
987
988static void copy_data_page(unsigned long dst_pfn, unsigned long src_pfn)
989{
990    struct page *s_page, *d_page;
991    void *src, *dst;
992
993    s_page = pfn_to_page(src_pfn);
994    d_page = pfn_to_page(dst_pfn);
995    if (PageHighMem(s_page)) {
996        src = kmap_atomic(s_page, KM_USER0);
997        dst = kmap_atomic(d_page, KM_USER1);
998        do_copy_page(dst, src);
999        kunmap_atomic(dst, KM_USER1);
1000        kunmap_atomic(src, KM_USER0);
1001    } else {
1002        if (PageHighMem(d_page)) {
1003            /* Page pointed to by src may contain some kernel
1004             * data modified by kmap_atomic()
1005             */
1006            safe_copy_page(buffer, s_page);
1007            dst = kmap_atomic(d_page, KM_USER0);
1008            copy_page(dst, buffer);
1009            kunmap_atomic(dst, KM_USER0);
1010        } else {
1011            safe_copy_page(page_address(d_page), s_page);
1012        }
1013    }
1014}
1015#else
1016#define page_is_saveable(zone, pfn) saveable_page(zone, pfn)
1017
1018static inline void copy_data_page(unsigned long dst_pfn, unsigned long src_pfn)
1019{
1020    safe_copy_page(page_address(pfn_to_page(dst_pfn)),
1021                pfn_to_page(src_pfn));
1022}
1023#endif /* CONFIG_HIGHMEM */
1024
1025static void
1026copy_data_pages(struct memory_bitmap *copy_bm, struct memory_bitmap *orig_bm)
1027{
1028    struct zone *zone;
1029    unsigned long pfn;
1030
1031    for_each_populated_zone(zone) {
1032        unsigned long max_zone_pfn;
1033
1034        mark_free_pages(zone);
1035        max_zone_pfn = zone->zone_start_pfn + zone->spanned_pages;
1036        for (pfn = zone->zone_start_pfn; pfn < max_zone_pfn; pfn++)
1037            if (page_is_saveable(zone, pfn))
1038                memory_bm_set_bit(orig_bm, pfn);
1039    }
1040    memory_bm_position_reset(orig_bm);
1041    memory_bm_position_reset(copy_bm);
1042    for(;;) {
1043        pfn = memory_bm_next_pfn(orig_bm);
1044        if (unlikely(pfn == BM_END_OF_MAP))
1045            break;
1046        copy_data_page(memory_bm_next_pfn(copy_bm), pfn);
1047    }
1048}
1049
1050/* Total number of image pages */
1051static unsigned int nr_copy_pages;
1052/* Number of pages needed for saving the original pfns of the image pages */
1053static unsigned int nr_meta_pages;
1054/*
1055 * Numbers of normal and highmem page frames allocated for hibernation image
1056 * before suspending devices.
1057 */
1058unsigned int alloc_normal, alloc_highmem;
1059/*
1060 * Memory bitmap used for marking saveable pages (during hibernation) or
1061 * hibernation image pages (during restore)
1062 */
1063static struct memory_bitmap orig_bm;
1064/*
1065 * Memory bitmap used during hibernation for marking allocated page frames that
1066 * will contain copies of saveable pages. During restore it is initially used
1067 * for marking hibernation image pages, but then the set bits from it are
1068 * duplicated in @orig_bm and it is released. On highmem systems it is next
1069 * used for marking "safe" highmem pages, but it has to be reinitialized for
1070 * this purpose.
1071 */
1072static struct memory_bitmap copy_bm;
1073
1074/**
1075 * swsusp_free - free pages allocated for the suspend.
1076 *
1077 * Suspend pages are alocated before the atomic copy is made, so we
1078 * need to release them after the resume.
1079 */
1080
1081void swsusp_free(void)
1082{
1083    struct zone *zone;
1084    unsigned long pfn, max_zone_pfn;
1085
1086    for_each_populated_zone(zone) {
1087        max_zone_pfn = zone->zone_start_pfn + zone->spanned_pages;
1088        for (pfn = zone->zone_start_pfn; pfn < max_zone_pfn; pfn++)
1089            if (pfn_valid(pfn)) {
1090                struct page *page = pfn_to_page(pfn);
1091
1092                if (swsusp_page_is_forbidden(page) &&
1093                    swsusp_page_is_free(page)) {
1094                    swsusp_unset_page_forbidden(page);
1095                    swsusp_unset_page_free(page);
1096                    __free_page(page);
1097                }
1098            }
1099    }
1100    nr_copy_pages = 0;
1101    nr_meta_pages = 0;
1102    restore_pblist = NULL;
1103    buffer = NULL;
1104    alloc_normal = 0;
1105    alloc_highmem = 0;
1106}
1107
1108/* Helper functions used for the shrinking of memory. */
1109
1110#define GFP_IMAGE (GFP_KERNEL | __GFP_NOWARN)
1111
1112/**
1113 * preallocate_image_pages - Allocate a number of pages for hibernation image
1114 * @nr_pages: Number of page frames to allocate.
1115 * @mask: GFP flags to use for the allocation.
1116 *
1117 * Return value: Number of page frames actually allocated
1118 */
1119static unsigned long preallocate_image_pages(unsigned long nr_pages, gfp_t mask)
1120{
1121    unsigned long nr_alloc = 0;
1122
1123    while (nr_pages > 0) {
1124        struct page *page;
1125
1126        page = alloc_image_page(mask);
1127        if (!page)
1128            break;
1129        memory_bm_set_bit(&copy_bm, page_to_pfn(page));
1130        if (PageHighMem(page))
1131            alloc_highmem++;
1132        else
1133            alloc_normal++;
1134        nr_pages--;
1135        nr_alloc++;
1136    }
1137
1138    return nr_alloc;
1139}
1140
1141static unsigned long preallocate_image_memory(unsigned long nr_pages,
1142                          unsigned long avail_normal)
1143{
1144    unsigned long alloc;
1145
1146    if (avail_normal <= alloc_normal)
1147        return 0;
1148
1149    alloc = avail_normal - alloc_normal;
1150    if (nr_pages < alloc)
1151        alloc = nr_pages;
1152
1153    return preallocate_image_pages(alloc, GFP_IMAGE);
1154}
1155
1156#ifdef CONFIG_HIGHMEM
1157static unsigned long preallocate_image_highmem(unsigned long nr_pages)
1158{
1159    return preallocate_image_pages(nr_pages, GFP_IMAGE | __GFP_HIGHMEM);
1160}
1161
1162/**
1163 * __fraction - Compute (an approximation of) x * (multiplier / base)
1164 */
1165static unsigned long __fraction(u64 x, u64 multiplier, u64 base)
1166{
1167    x *= multiplier;
1168    do_div(x, base);
1169    return (unsigned long)x;
1170}
1171
1172static unsigned long preallocate_highmem_fraction(unsigned long nr_pages,
1173                        unsigned long highmem,
1174                        unsigned long total)
1175{
1176    unsigned long alloc = __fraction(nr_pages, highmem, total);
1177
1178    return preallocate_image_pages(alloc, GFP_IMAGE | __GFP_HIGHMEM);
1179}
1180#else /* CONFIG_HIGHMEM */
1181static inline unsigned long preallocate_image_highmem(unsigned long nr_pages)
1182{
1183    return 0;
1184}
1185
1186static inline unsigned long preallocate_highmem_fraction(unsigned long nr_pages,
1187                        unsigned long highmem,
1188                        unsigned long total)
1189{
1190    return 0;
1191}
1192#endif /* CONFIG_HIGHMEM */
1193
1194/**
1195 * free_unnecessary_pages - Release preallocated pages not needed for the image
1196 */
1197static void free_unnecessary_pages(void)
1198{
1199    unsigned long save, to_free_normal, to_free_highmem;
1200
1201    save = count_data_pages();
1202    if (alloc_normal >= save) {
1203        to_free_normal = alloc_normal - save;
1204        save = 0;
1205    } else {
1206        to_free_normal = 0;
1207        save -= alloc_normal;
1208    }
1209    save += count_highmem_pages();
1210    if (alloc_highmem >= save) {
1211        to_free_highmem = alloc_highmem - save;
1212    } else {
1213        to_free_highmem = 0;
1214        save -= alloc_highmem;
1215        if (to_free_normal > save)
1216            to_free_normal -= save;
1217        else
1218            to_free_normal = 0;
1219    }
1220
1221    memory_bm_position_reset(&copy_bm);
1222
1223    while (to_free_normal > 0 || to_free_highmem > 0) {
1224        unsigned long pfn = memory_bm_next_pfn(&copy_bm);
1225        struct page *page = pfn_to_page(pfn);
1226
1227        if (PageHighMem(page)) {
1228            if (!to_free_highmem)
1229                continue;
1230            to_free_highmem--;
1231            alloc_highmem--;
1232        } else {
1233            if (!to_free_normal)
1234                continue;
1235            to_free_normal--;
1236            alloc_normal--;
1237        }
1238        memory_bm_clear_bit(&copy_bm, pfn);
1239        swsusp_unset_page_forbidden(page);
1240        swsusp_unset_page_free(page);
1241        __free_page(page);
1242    }
1243}
1244
1245/**
1246 * minimum_image_size - Estimate the minimum acceptable size of an image
1247 * @saveable: Number of saveable pages in the system.
1248 *
1249 * We want to avoid attempting to free too much memory too hard, so estimate the
1250 * minimum acceptable size of a hibernation image to use as the lower limit for
1251 * preallocating memory.
1252 *
1253 * We assume that the minimum image size should be proportional to
1254 *
1255 * [number of saveable pages] - [number of pages that can be freed in theory]
1256 *
1257 * where the second term is the sum of (1) reclaimable slab pages, (2) active
1258 * and (3) inactive anonymouns pages, (4) active and (5) inactive file pages,
1259 * minus mapped file pages.
1260 */
1261static unsigned long minimum_image_size(unsigned long saveable)
1262{
1263    unsigned long size;
1264
1265    size = global_page_state(NR_SLAB_RECLAIMABLE)
1266        + global_page_state(NR_ACTIVE_ANON)
1267        + global_page_state(NR_INACTIVE_ANON)
1268        + global_page_state(NR_ACTIVE_FILE)
1269        + global_page_state(NR_INACTIVE_FILE)
1270        - global_page_state(NR_FILE_MAPPED);
1271
1272    return saveable <= size ? 0 : saveable - size;
1273}
1274
1275/**
1276 * hibernate_preallocate_memory - Preallocate memory for hibernation image
1277 *
1278 * To create a hibernation image it is necessary to make a copy of every page
1279 * frame in use. We also need a number of page frames to be free during
1280 * hibernation for allocations made while saving the image and for device
1281 * drivers, in case they need to allocate memory from their hibernation
1282 * callbacks (these two numbers are given by PAGES_FOR_IO (which is a rough
1283 * estimate) and reserverd_size divided by PAGE_SIZE (which is tunable through
1284 * /sys/power/reserved_size, respectively). To make this happen, we compute the
1285 * total number of available page frames and allocate at least
1286 *
1287 * ([page frames total] + PAGES_FOR_IO + [metadata pages]) / 2
1288 * + 2 * DIV_ROUND_UP(reserved_size, PAGE_SIZE)
1289 *
1290 * of them, which corresponds to the maximum size of a hibernation image.
1291 *
1292 * If image_size is set below the number following from the above formula,
1293 * the preallocation of memory is continued until the total number of saveable
1294 * pages in the system is below the requested image size or the minimum
1295 * acceptable image size returned by minimum_image_size(), whichever is greater.
1296 */
1297int hibernate_preallocate_memory(void)
1298{
1299    struct zone *zone;
1300    unsigned long saveable, size, max_size, count, highmem, pages = 0;
1301    unsigned long alloc, save_highmem, pages_highmem, avail_normal;
1302    struct timeval start, stop;
1303    int error;
1304
1305    printk(KERN_INFO "PM: Preallocating image memory... ");
1306    do_gettimeofday(&start);
1307
1308    error = memory_bm_create(&orig_bm, GFP_IMAGE, PG_ANY);
1309    if (error)
1310        goto err_out;
1311
1312    error = memory_bm_create(&copy_bm, GFP_IMAGE, PG_ANY);
1313    if (error)
1314        goto err_out;
1315
1316    alloc_normal = 0;
1317    alloc_highmem = 0;
1318
1319    /* Count the number of saveable data pages. */
1320    save_highmem = count_highmem_pages();
1321    saveable = count_data_pages();
1322
1323    /*
1324     * Compute the total number of page frames we can use (count) and the
1325     * number of pages needed for image metadata (size).
1326     */
1327    count = saveable;
1328    saveable += save_highmem;
1329    highmem = save_highmem;
1330    size = 0;
1331    for_each_populated_zone(zone) {
1332        size += snapshot_additional_pages(zone);
1333        if (is_highmem(zone))
1334            highmem += zone_page_state(zone, NR_FREE_PAGES);
1335        else
1336            count += zone_page_state(zone, NR_FREE_PAGES);
1337    }
1338    avail_normal = count;
1339    count += highmem;
1340    count -= totalreserve_pages;
1341
1342    /* Compute the maximum number of saveable pages to leave in memory. */
1343    max_size = (count - (size + PAGES_FOR_IO)) / 2
1344            - 2 * DIV_ROUND_UP(reserved_size, PAGE_SIZE);
1345    /* Compute the desired number of image pages specified by image_size. */
1346    size = DIV_ROUND_UP(image_size, PAGE_SIZE);
1347    if (size > max_size)
1348        size = max_size;
1349    /*
1350     * If the desired number of image pages is at least as large as the
1351     * current number of saveable pages in memory, allocate page frames for
1352     * the image and we're done.
1353     */
1354    if (size >= saveable) {
1355        pages = preallocate_image_highmem(save_highmem);
1356        pages += preallocate_image_memory(saveable - pages, avail_normal);
1357        goto out;
1358    }
1359
1360    /* Estimate the minimum size of the image. */
1361    pages = minimum_image_size(saveable);
1362    /*
1363     * To avoid excessive pressure on the normal zone, leave room in it to
1364     * accommodate an image of the minimum size (unless it's already too
1365     * small, in which case don't preallocate pages from it at all).
1366     */
1367    if (avail_normal > pages)
1368        avail_normal -= pages;
1369    else
1370        avail_normal = 0;
1371    if (size < pages)
1372        size = min_t(unsigned long, pages, max_size);
1373
1374    /*
1375     * Let the memory management subsystem know that we're going to need a
1376     * large number of page frames to allocate and make it free some memory.
1377     * NOTE: If this is not done, performance will be hurt badly in some
1378     * test cases.
1379     */
1380    shrink_all_memory(saveable - size);
1381
1382    /*
1383     * The number of saveable pages in memory was too high, so apply some
1384     * pressure to decrease it. First, make room for the largest possible
1385     * image and fail if that doesn't work. Next, try to decrease the size
1386     * of the image as much as indicated by 'size' using allocations from
1387     * highmem and non-highmem zones separately.
1388     */
1389    pages_highmem = preallocate_image_highmem(highmem / 2);
1390    alloc = (count - max_size) - pages_highmem;
1391    pages = preallocate_image_memory(alloc, avail_normal);
1392    if (pages < alloc) {
1393        /* We have exhausted non-highmem pages, try highmem. */
1394        alloc -= pages;
1395        pages += pages_highmem;
1396        pages_highmem = preallocate_image_highmem(alloc);
1397        if (pages_highmem < alloc)
1398            goto err_out;
1399        pages += pages_highmem;
1400        /*
1401         * size is the desired number of saveable pages to leave in
1402         * memory, so try to preallocate (all memory - size) pages.
1403         */
1404        alloc = (count - pages) - size;
1405        pages += preallocate_image_highmem(alloc);
1406    } else {
1407        /*
1408         * There are approximately max_size saveable pages at this point
1409         * and we want to reduce this number down to size.
1410         */
1411        alloc = max_size - size;
1412        size = preallocate_highmem_fraction(alloc, highmem, count);
1413        pages_highmem += size;
1414        alloc -= size;
1415        size = preallocate_image_memory(alloc, avail_normal);
1416        pages_highmem += preallocate_image_highmem(alloc - size);
1417        pages += pages_highmem + size;
1418    }
1419
1420    /*
1421     * We only need as many page frames for the image as there are saveable
1422     * pages in memory, but we have allocated more. Release the excessive
1423     * ones now.
1424     */
1425    free_unnecessary_pages();
1426
1427 out:
1428    do_gettimeofday(&stop);
1429    printk(KERN_CONT "done (allocated %lu pages)\n", pages);
1430    swsusp_show_speed(&start, &stop, pages, "Allocated");
1431
1432    return 0;
1433
1434 err_out:
1435    printk(KERN_CONT "\n");
1436    swsusp_free();
1437    return -ENOMEM;
1438}
1439
1440#ifdef CONFIG_HIGHMEM
1441/**
1442  * count_pages_for_highmem - compute the number of non-highmem pages
1443  * that will be necessary for creating copies of highmem pages.
1444  */
1445
1446static unsigned int count_pages_for_highmem(unsigned int nr_highmem)
1447{
1448    unsigned int free_highmem = count_free_highmem_pages() + alloc_highmem;
1449
1450    if (free_highmem >= nr_highmem)
1451        nr_highmem = 0;
1452    else
1453        nr_highmem -= free_highmem;
1454
1455    return nr_highmem;
1456}
1457#else
1458static unsigned int
1459count_pages_for_highmem(unsigned int nr_highmem) { return 0; }
1460#endif /* CONFIG_HIGHMEM */
1461
1462/**
1463 * enough_free_mem - Make sure we have enough free memory for the
1464 * snapshot image.
1465 */
1466
1467static int enough_free_mem(unsigned int nr_pages, unsigned int nr_highmem)
1468{
1469    struct zone *zone;
1470    unsigned int free = alloc_normal;
1471
1472    for_each_populated_zone(zone)
1473        if (!is_highmem(zone))
1474            free += zone_page_state(zone, NR_FREE_PAGES);
1475
1476    nr_pages += count_pages_for_highmem(nr_highmem);
1477    pr_debug("PM: Normal pages needed: %u + %u, available pages: %u\n",
1478        nr_pages, PAGES_FOR_IO, free);
1479
1480    return free > nr_pages + PAGES_FOR_IO;
1481}
1482
1483#ifdef CONFIG_HIGHMEM
1484/**
1485 * get_highmem_buffer - if there are some highmem pages in the suspend
1486 * image, we may need the buffer to copy them and/or load their data.
1487 */
1488
1489static inline int get_highmem_buffer(int safe_needed)
1490{
1491    buffer = get_image_page(GFP_ATOMIC | __GFP_COLD, safe_needed);
1492    return buffer ? 0 : -ENOMEM;
1493}
1494
1495/**
1496 * alloc_highmem_image_pages - allocate some highmem pages for the image.
1497 * Try to allocate as many pages as needed, but if the number of free
1498 * highmem pages is lesser than that, allocate them all.
1499 */
1500
1501static inline unsigned int
1502alloc_highmem_pages(struct memory_bitmap *bm, unsigned int nr_highmem)
1503{
1504    unsigned int to_alloc = count_free_highmem_pages();
1505
1506    if (to_alloc > nr_highmem)
1507        to_alloc = nr_highmem;
1508
1509    nr_highmem -= to_alloc;
1510    while (to_alloc-- > 0) {
1511        struct page *page;
1512
1513        page = alloc_image_page(__GFP_HIGHMEM);
1514        memory_bm_set_bit(bm, page_to_pfn(page));
1515    }
1516    return nr_highmem;
1517}
1518#else
1519static inline int get_highmem_buffer(int safe_needed) { return 0; }
1520
1521static inline unsigned int
1522alloc_highmem_pages(struct memory_bitmap *bm, unsigned int n) { return 0; }
1523#endif /* CONFIG_HIGHMEM */
1524
1525/**
1526 * swsusp_alloc - allocate memory for the suspend image
1527 *
1528 * We first try to allocate as many highmem pages as there are
1529 * saveable highmem pages in the system. If that fails, we allocate
1530 * non-highmem pages for the copies of the remaining highmem ones.
1531 *
1532 * In this approach it is likely that the copies of highmem pages will
1533 * also be located in the high memory, because of the way in which
1534 * copy_data_pages() works.
1535 */
1536
1537static int
1538swsusp_alloc(struct memory_bitmap *orig_bm, struct memory_bitmap *copy_bm,
1539        unsigned int nr_pages, unsigned int nr_highmem)
1540{
1541    if (nr_highmem > 0) {
1542        if (get_highmem_buffer(PG_ANY))
1543            goto err_out;
1544        if (nr_highmem > alloc_highmem) {
1545            nr_highmem -= alloc_highmem;
1546            nr_pages += alloc_highmem_pages(copy_bm, nr_highmem);
1547        }
1548    }
1549    if (nr_pages > alloc_normal) {
1550        nr_pages -= alloc_normal;
1551        while (nr_pages-- > 0) {
1552            struct page *page;
1553
1554            page = alloc_image_page(GFP_ATOMIC | __GFP_COLD);
1555            if (!page)
1556                goto err_out;
1557            memory_bm_set_bit(copy_bm, page_to_pfn(page));
1558        }
1559    }
1560
1561    return 0;
1562
1563 err_out:
1564    swsusp_free();
1565    return -ENOMEM;
1566}
1567
1568asmlinkage int swsusp_save(void)
1569{
1570    unsigned int nr_pages, nr_highmem;
1571
1572    printk(KERN_INFO "PM: Creating hibernation image:\n");
1573
1574    drain_local_pages(NULL);
1575    nr_pages = count_data_pages();
1576    nr_highmem = count_highmem_pages();
1577    printk(KERN_INFO "PM: Need to copy %u pages\n", nr_pages + nr_highmem);
1578
1579    if (!enough_free_mem(nr_pages, nr_highmem)) {
1580        printk(KERN_ERR "PM: Not enough free memory\n");
1581        return -ENOMEM;
1582    }
1583
1584    if (swsusp_alloc(&orig_bm, &copy_bm, nr_pages, nr_highmem)) {
1585        printk(KERN_ERR "PM: Memory allocation failed\n");
1586        return -ENOMEM;
1587    }
1588
1589    /* During allocating of suspend pagedir, new cold pages may appear.
1590     * Kill them.
1591     */
1592    drain_local_pages(NULL);
1593    copy_data_pages(&copy_bm, &orig_bm);
1594
1595    /*
1596     * End of critical section. From now on, we can write to memory,
1597     * but we should not touch disk. This specially means we must _not_
1598     * touch swap space! Except we must write out our image of course.
1599     */
1600
1601    nr_pages += nr_highmem;
1602    nr_copy_pages = nr_pages;
1603    nr_meta_pages = DIV_ROUND_UP(nr_pages * sizeof(long), PAGE_SIZE);
1604
1605    printk(KERN_INFO "PM: Hibernation image created (%d pages copied)\n",
1606        nr_pages);
1607
1608    return 0;
1609}
1610
1611#ifndef CONFIG_ARCH_HIBERNATION_HEADER
1612static int init_header_complete(struct swsusp_info *info)
1613{
1614    memcpy(&info->uts, init_utsname(), sizeof(struct new_utsname));
1615    info->version_code = LINUX_VERSION_CODE;
1616    return 0;
1617}
1618
1619static char *check_image_kernel(struct swsusp_info *info)
1620{
1621    if (info->version_code != LINUX_VERSION_CODE)
1622        return "kernel version";
1623    if (strcmp(info->uts.sysname,init_utsname()->sysname))
1624        return "system type";
1625    if (strcmp(info->uts.release,init_utsname()->release))
1626        return "kernel release";
1627    if (strcmp(info->uts.version,init_utsname()->version))
1628        return "version";
1629    if (strcmp(info->uts.machine,init_utsname()->machine))
1630        return "machine";
1631    return NULL;
1632}
1633#endif /* CONFIG_ARCH_HIBERNATION_HEADER */
1634
1635unsigned long snapshot_get_image_size(void)
1636{
1637    return nr_copy_pages + nr_meta_pages + 1;
1638}
1639
1640static int init_header(struct swsusp_info *info)
1641{
1642    memset(info, 0, sizeof(struct swsusp_info));
1643    info->num_physpages = num_physpages;
1644    info->image_pages = nr_copy_pages;
1645    info->pages = snapshot_get_image_size();
1646    info->size = info->pages;
1647    info->size <<= PAGE_SHIFT;
1648    return init_header_complete(info);
1649}
1650
1651/**
1652 * pack_pfns - pfns corresponding to the set bits found in the bitmap @bm
1653 * are stored in the array @buf[] (1 page at a time)
1654 */
1655
1656static inline void
1657pack_pfns(unsigned long *buf, struct memory_bitmap *bm)
1658{
1659    int j;
1660
1661    for (j = 0; j < PAGE_SIZE / sizeof(long); j++) {
1662        buf[j] = memory_bm_next_pfn(bm);
1663        if (unlikely(buf[j] == BM_END_OF_MAP))
1664            break;
1665    }
1666}
1667
1668/**
1669 * snapshot_read_next - used for reading the system memory snapshot.
1670 *
1671 * On the first call to it @handle should point to a zeroed
1672 * snapshot_handle structure. The structure gets updated and a pointer
1673 * to it should be passed to this function every next time.
1674 *
1675 * On success the function returns a positive number. Then, the caller
1676 * is allowed to read up to the returned number of bytes from the memory
1677 * location computed by the data_of() macro.
1678 *
1679 * The function returns 0 to indicate the end of data stream condition,
1680 * and a negative number is returned on error. In such cases the
1681 * structure pointed to by @handle is not updated and should not be used
1682 * any more.
1683 */
1684
1685int snapshot_read_next(struct snapshot_handle *handle)
1686{
1687    if (handle->cur > nr_meta_pages + nr_copy_pages)
1688        return 0;
1689
1690    if (!buffer) {
1691        /* This makes the buffer be freed by swsusp_free() */
1692        buffer = get_image_page(GFP_ATOMIC, PG_ANY);
1693        if (!buffer)
1694            return -ENOMEM;
1695    }
1696    if (!handle->cur) {
1697        int error;
1698
1699        error = init_header((struct swsusp_info *)buffer);
1700        if (error)
1701            return error;
1702        handle->buffer = buffer;
1703        memory_bm_position_reset(&orig_bm);
1704        memory_bm_position_reset(&copy_bm);
1705    } else if (handle->cur <= nr_meta_pages) {
1706        clear_page(buffer);
1707        pack_pfns(buffer, &orig_bm);
1708    } else {
1709        struct page *page;
1710
1711        page = pfn_to_page(memory_bm_next_pfn(&copy_bm));
1712        if (PageHighMem(page)) {
1713            /* Highmem pages are copied to the buffer,
1714             * because we can't return with a kmapped
1715             * highmem page (we may not be called again).
1716             */
1717            void *kaddr;
1718
1719            kaddr = kmap_atomic(page, KM_USER0);
1720            copy_page(buffer, kaddr);
1721            kunmap_atomic(kaddr, KM_USER0);
1722            handle->buffer = buffer;
1723        } else {
1724            handle->buffer = page_address(page);
1725        }
1726    }
1727    handle->cur++;
1728    return PAGE_SIZE;
1729}
1730
1731/**
1732 * mark_unsafe_pages - mark the pages that cannot be used for storing
1733 * the image during resume, because they conflict with the pages that
1734 * had been used before suspend
1735 */
1736
1737static int mark_unsafe_pages(struct memory_bitmap *bm)
1738{
1739    struct zone *zone;
1740    unsigned long pfn, max_zone_pfn;
1741
1742    /* Clear page flags */
1743    for_each_populated_zone(zone) {
1744        max_zone_pfn = zone->zone_start_pfn + zone->spanned_pages;
1745        for (pfn = zone->zone_start_pfn; pfn < max_zone_pfn; pfn++)
1746            if (pfn_valid(pfn))
1747                swsusp_unset_page_free(pfn_to_page(pfn));
1748    }
1749
1750    /* Mark pages that correspond to the "original" pfns as "unsafe" */
1751    memory_bm_position_reset(bm);
1752    do {
1753        pfn = memory_bm_next_pfn(bm);
1754        if (likely(pfn != BM_END_OF_MAP)) {
1755            if (likely(pfn_valid(pfn)))
1756                swsusp_set_page_free(pfn_to_page(pfn));
1757            else
1758                return -EFAULT;
1759        }
1760    } while (pfn != BM_END_OF_MAP);
1761
1762    allocated_unsafe_pages = 0;
1763
1764    return 0;
1765}
1766
1767static void
1768duplicate_memory_bitmap(struct memory_bitmap *dst, struct memory_bitmap *src)
1769{
1770    unsigned long pfn;
1771
1772    memory_bm_position_reset(src);
1773    pfn = memory_bm_next_pfn(src);
1774    while (pfn != BM_END_OF_MAP) {
1775        memory_bm_set_bit(dst, pfn);
1776        pfn = memory_bm_next_pfn(src);
1777    }
1778}
1779
1780static int check_header(struct swsusp_info *info)
1781{
1782    char *reason;
1783
1784    reason = check_image_kernel(info);
1785    if (!reason && info->num_physpages != num_physpages)
1786        reason = "memory size";
1787    if (reason) {
1788        printk(KERN_ERR "PM: Image mismatch: %s\n", reason);
1789        return -EPERM;
1790    }
1791    return 0;
1792}
1793
1794/**
1795 * load header - check the image header and copy data from it
1796 */
1797
1798static int
1799load_header(struct swsusp_info *info)
1800{
1801    int error;
1802
1803    restore_pblist = NULL;
1804    error = check_header(info);
1805    if (!error) {
1806        nr_copy_pages = info->image_pages;
1807        nr_meta_pages = info->pages - info->image_pages - 1;
1808    }
1809    return error;
1810}
1811
1812/**
1813 * unpack_orig_pfns - for each element of @buf[] (1 page at a time) set
1814 * the corresponding bit in the memory bitmap @bm
1815 */
1816static int unpack_orig_pfns(unsigned long *buf, struct memory_bitmap *bm)
1817{
1818    int j;
1819
1820    for (j = 0; j < PAGE_SIZE / sizeof(long); j++) {
1821        if (unlikely(buf[j] == BM_END_OF_MAP))
1822            break;
1823
1824        if (memory_bm_pfn_present(bm, buf[j]))
1825            memory_bm_set_bit(bm, buf[j]);
1826        else
1827            return -EFAULT;
1828    }
1829
1830    return 0;
1831}
1832
1833/* List of "safe" pages that may be used to store data loaded from the suspend
1834 * image
1835 */
1836static struct linked_page *safe_pages_list;
1837
1838#ifdef CONFIG_HIGHMEM
1839/* struct highmem_pbe is used for creating the list of highmem pages that
1840 * should be restored atomically during the resume from disk, because the page
1841 * frames they have occupied before the suspend are in use.
1842 */
1843struct highmem_pbe {
1844    struct page *copy_page; /* data is here now */
1845    struct page *orig_page; /* data was here before the suspend */
1846    struct highmem_pbe *next;
1847};
1848
1849/* List of highmem PBEs needed for restoring the highmem pages that were
1850 * allocated before the suspend and included in the suspend image, but have
1851 * also been allocated by the "resume" kernel, so their contents cannot be
1852 * written directly to their "original" page frames.
1853 */
1854static struct highmem_pbe *highmem_pblist;
1855
1856/**
1857 * count_highmem_image_pages - compute the number of highmem pages in the
1858 * suspend image. The bits in the memory bitmap @bm that correspond to the
1859 * image pages are assumed to be set.
1860 */
1861
1862static unsigned int count_highmem_image_pages(struct memory_bitmap *bm)
1863{
1864    unsigned long pfn;
1865    unsigned int cnt = 0;
1866
1867    memory_bm_position_reset(bm);
1868    pfn = memory_bm_next_pfn(bm);
1869    while (pfn != BM_END_OF_MAP) {
1870        if (PageHighMem(pfn_to_page(pfn)))
1871            cnt++;
1872
1873        pfn = memory_bm_next_pfn(bm);
1874    }
1875    return cnt;
1876}
1877
1878/**
1879 * prepare_highmem_image - try to allocate as many highmem pages as
1880 * there are highmem image pages (@nr_highmem_p points to the variable
1881 * containing the number of highmem image pages). The pages that are
1882 * "safe" (ie. will not be overwritten when the suspend image is
1883 * restored) have the corresponding bits set in @bm (it must be
1884 * unitialized).
1885 *
1886 * NOTE: This function should not be called if there are no highmem
1887 * image pages.
1888 */
1889
1890static unsigned int safe_highmem_pages;
1891
1892static struct memory_bitmap *safe_highmem_bm;
1893
1894static int
1895prepare_highmem_image(struct memory_bitmap *bm, unsigned int *nr_highmem_p)
1896{
1897    unsigned int to_alloc;
1898
1899    if (memory_bm_create(bm, GFP_ATOMIC, PG_SAFE))
1900        return -ENOMEM;
1901
1902    if (get_highmem_buffer(PG_SAFE))
1903        return -ENOMEM;
1904
1905    to_alloc = count_free_highmem_pages();
1906    if (to_alloc > *nr_highmem_p)
1907        to_alloc = *nr_highmem_p;
1908    else
1909        *nr_highmem_p = to_alloc;
1910
1911    safe_highmem_pages = 0;
1912    while (to_alloc-- > 0) {
1913        struct page *page;
1914
1915        page = alloc_page(__GFP_HIGHMEM);
1916        if (!swsusp_page_is_free(page)) {
1917            /* The page is "safe", set its bit the bitmap */
1918            memory_bm_set_bit(bm, page_to_pfn(page));
1919            safe_highmem_pages++;
1920        }
1921        /* Mark the page as allocated */
1922        swsusp_set_page_forbidden(page);
1923        swsusp_set_page_free(page);
1924    }
1925    memory_bm_position_reset(bm);
1926    safe_highmem_bm = bm;
1927    return 0;
1928}
1929
1930/**
1931 * get_highmem_page_buffer - for given highmem image page find the buffer
1932 * that suspend_write_next() should set for its caller to write to.
1933 *
1934 * If the page is to be saved to its "original" page frame or a copy of
1935 * the page is to be made in the highmem, @buffer is returned. Otherwise,
1936 * the copy of the page is to be made in normal memory, so the address of
1937 * the copy is returned.
1938 *
1939 * If @buffer is returned, the caller of suspend_write_next() will write
1940 * the page's contents to @buffer, so they will have to be copied to the
1941 * right location on the next call to suspend_write_next() and it is done
1942 * with the help of copy_last_highmem_page(). For this purpose, if
1943 * @buffer is returned, @last_highmem page is set to the page to which
1944 * the data will have to be copied from @buffer.
1945 */
1946
1947static struct page *last_highmem_page;
1948
1949static void *
1950get_highmem_page_buffer(struct page *page, struct chain_allocator *ca)
1951{
1952    struct highmem_pbe *pbe;
1953    void *kaddr;
1954
1955    if (swsusp_page_is_forbidden(page) && swsusp_page_is_free(page)) {
1956        /* We have allocated the "original" page frame and we can
1957         * use it directly to store the loaded page.
1958         */
1959        last_highmem_page = page;
1960        return buffer;
1961    }
1962    /* The "original" page frame has not been allocated and we have to
1963     * use a "safe" page frame to store the loaded page.
1964     */
1965    pbe = chain_alloc(ca, sizeof(struct highmem_pbe));
1966    if (!pbe) {
1967        swsusp_free();
1968        return ERR_PTR(-ENOMEM);
1969    }
1970    pbe->orig_page = page;
1971    if (safe_highmem_pages > 0) {
1972        struct page *tmp;
1973
1974        /* Copy of the page will be stored in high memory */
1975        kaddr = buffer;
1976        tmp = pfn_to_page(memory_bm_next_pfn(safe_highmem_bm));
1977        safe_highmem_pages--;
1978        last_highmem_page = tmp;
1979        pbe->copy_page = tmp;
1980    } else {
1981        /* Copy of the page will be stored in normal memory */
1982        kaddr = safe_pages_list;
1983        safe_pages_list = safe_pages_list->next;
1984        pbe->copy_page = virt_to_page(kaddr);
1985    }
1986    pbe->next = highmem_pblist;
1987    highmem_pblist = pbe;
1988    return kaddr;
1989}
1990
1991/**
1992 * copy_last_highmem_page - copy the contents of a highmem image from
1993 * @buffer, where the caller of snapshot_write_next() has place them,
1994 * to the right location represented by @last_highmem_page .
1995 */
1996
1997static void copy_last_highmem_page(void)
1998{
1999    if (last_highmem_page) {
2000        void *dst;
2001
2002        dst = kmap_atomic(last_highmem_page, KM_USER0);
2003        copy_page(dst, buffer);
2004        kunmap_atomic(dst, KM_USER0);
2005        last_highmem_page = NULL;
2006    }
2007}
2008
2009static inline int last_highmem_page_copied(void)
2010{
2011    return !last_highmem_page;
2012}
2013
2014static inline void free_highmem_data(void)
2015{
2016    if (safe_highmem_bm)
2017        memory_bm_free(safe_highmem_bm, PG_UNSAFE_CLEAR);
2018
2019    if (buffer)
2020        free_image_page(buffer, PG_UNSAFE_CLEAR);
2021}
2022#else
2023static inline int get_safe_write_buffer(void) { return 0; }
2024
2025static unsigned int
2026count_highmem_image_pages(struct memory_bitmap *bm) { return 0; }
2027
2028static inline int
2029prepare_highmem_image(struct memory_bitmap *bm, unsigned int *nr_highmem_p)
2030{
2031    return 0;
2032}
2033
2034static inline void *
2035get_highmem_page_buffer(struct page *page, struct chain_allocator *ca)
2036{
2037    return ERR_PTR(-EINVAL);
2038}
2039
2040static inline void copy_last_highmem_page(void) {}
2041static inline int last_highmem_page_copied(void) { return 1; }
2042static inline void free_highmem_data(void) {}
2043#endif /* CONFIG_HIGHMEM */
2044
2045/**
2046 * prepare_image - use the memory bitmap @bm to mark the pages that will
2047 * be overwritten in the process of restoring the system memory state
2048 * from the suspend image ("unsafe" pages) and allocate memory for the
2049 * image.
2050 *
2051 * The idea is to allocate a new memory bitmap first and then allocate
2052 * as many pages as needed for the image data, but not to assign these
2053 * pages to specific tasks initially. Instead, we just mark them as
2054 * allocated and create a lists of "safe" pages that will be used
2055 * later. On systems with high memory a list of "safe" highmem pages is
2056 * also created.
2057 */
2058
2059#define PBES_PER_LINKED_PAGE (LINKED_PAGE_DATA_SIZE / sizeof(struct pbe))
2060
2061static int
2062prepare_image(struct memory_bitmap *new_bm, struct memory_bitmap *bm)
2063{
2064    unsigned int nr_pages, nr_highmem;
2065    struct linked_page *sp_list, *lp;
2066    int error;
2067
2068    /* If there is no highmem, the buffer will not be necessary */
2069    free_image_page(buffer, PG_UNSAFE_CLEAR);
2070    buffer = NULL;
2071
2072    nr_highmem = count_highmem_image_pages(bm);
2073    error = mark_unsafe_pages(bm);
2074    if (error)
2075        goto Free;
2076
2077    error = memory_bm_create(new_bm, GFP_ATOMIC, PG_SAFE);
2078    if (error)
2079        goto Free;
2080
2081    duplicate_memory_bitmap(new_bm, bm);
2082    memory_bm_free(bm, PG_UNSAFE_KEEP);
2083    if (nr_highmem > 0) {
2084        error = prepare_highmem_image(bm, &nr_highmem);
2085        if (error)
2086            goto Free;
2087    }
2088    /* Reserve some safe pages for potential later use.
2089     *
2090     * NOTE: This way we make sure there will be enough safe pages for the
2091     * chain_alloc() in get_buffer(). It is a bit wasteful, but
2092     * nr_copy_pages cannot be greater than 50% of the memory anyway.
2093     */
2094    sp_list = NULL;
2095    /* nr_copy_pages cannot be lesser than allocated_unsafe_pages */
2096    nr_pages = nr_copy_pages - nr_highmem - allocated_unsafe_pages;
2097    nr_pages = DIV_ROUND_UP(nr_pages, PBES_PER_LINKED_PAGE);
2098    while (nr_pages > 0) {
2099        lp = get_image_page(GFP_ATOMIC, PG_SAFE);
2100        if (!lp) {
2101            error = -ENOMEM;
2102            goto Free;
2103        }
2104        lp->next = sp_list;
2105        sp_list = lp;
2106        nr_pages--;
2107    }
2108    /* Preallocate memory for the image */
2109    safe_pages_list = NULL;
2110    nr_pages = nr_copy_pages - nr_highmem - allocated_unsafe_pages;
2111    while (nr_pages > 0) {
2112        lp = (struct linked_page *)get_zeroed_page(GFP_ATOMIC);
2113        if (!lp) {
2114            error = -ENOMEM;
2115            goto Free;
2116        }
2117        if (!swsusp_page_is_free(virt_to_page(lp))) {
2118            /* The page is "safe", add it to the list */
2119            lp->next = safe_pages_list;
2120            safe_pages_list = lp;
2121        }
2122        /* Mark the page as allocated */
2123        swsusp_set_page_forbidden(virt_to_page(lp));
2124        swsusp_set_page_free(virt_to_page(lp));
2125        nr_pages--;
2126    }
2127    /* Free the reserved safe pages so that chain_alloc() can use them */
2128    while (sp_list) {
2129        lp = sp_list->next;
2130        free_image_page(sp_list, PG_UNSAFE_CLEAR);
2131        sp_list = lp;
2132    }
2133    return 0;
2134
2135 Free:
2136    swsusp_free();
2137    return error;
2138}
2139
2140/**
2141 * get_buffer - compute the address that snapshot_write_next() should
2142 * set for its caller to write to.
2143 */
2144
2145static void *get_buffer(struct memory_bitmap *bm, struct chain_allocator *ca)
2146{
2147    struct pbe *pbe;
2148    struct page *page;
2149    unsigned long pfn = memory_bm_next_pfn(bm);
2150
2151    if (pfn == BM_END_OF_MAP)
2152        return ERR_PTR(-EFAULT);
2153
2154    page = pfn_to_page(pfn);
2155    if (PageHighMem(page))
2156        return get_highmem_page_buffer(page, ca);
2157
2158    if (swsusp_page_is_forbidden(page) && swsusp_page_is_free(page))
2159        /* We have allocated the "original" page frame and we can
2160         * use it directly to store the loaded page.
2161         */
2162        return page_address(page);
2163
2164    /* The "original" page frame has not been allocated and we have to
2165     * use a "safe" page frame to store the loaded page.
2166     */
2167    pbe = chain_alloc(ca, sizeof(struct pbe));
2168    if (!pbe) {
2169        swsusp_free();
2170        return ERR_PTR(-ENOMEM);
2171    }
2172    pbe->orig_address = page_address(page);
2173    pbe->address = safe_pages_list;
2174    safe_pages_list = safe_pages_list->next;
2175    pbe->next = restore_pblist;
2176    restore_pblist = pbe;
2177    return pbe->address;
2178}
2179
2180/**
2181 * snapshot_write_next - used for writing the system memory snapshot.
2182 *
2183 * On the first call to it @handle should point to a zeroed
2184 * snapshot_handle structure. The structure gets updated and a pointer
2185 * to it should be passed to this function every next time.
2186 *
2187 * On success the function returns a positive number. Then, the caller
2188 * is allowed to write up to the returned number of bytes to the memory
2189 * location computed by the data_of() macro.
2190 *
2191 * The function returns 0 to indicate the "end of file" condition,
2192 * and a negative number is returned on error. In such cases the
2193 * structure pointed to by @handle is not updated and should not be used
2194 * any more.
2195 */
2196
2197int snapshot_write_next(struct snapshot_handle *handle)
2198{
2199    static struct chain_allocator ca;
2200    int error = 0;
2201
2202    /* Check if we have already loaded the entire image */
2203    if (handle->cur > 1 && handle->cur > nr_meta_pages + nr_copy_pages)
2204        return 0;
2205
2206    handle->sync_read = 1;
2207
2208    if (!handle->cur) {
2209        if (!buffer)
2210            /* This makes the buffer be freed by swsusp_free() */
2211            buffer = get_image_page(GFP_ATOMIC, PG_ANY);
2212
2213        if (!buffer)
2214            return -ENOMEM;
2215
2216        handle->buffer = buffer;
2217    } else if (handle->cur == 1) {
2218        error = load_header(buffer);
2219        if (error)
2220            return error;
2221
2222        error = memory_bm_create(&copy_bm, GFP_ATOMIC, PG_ANY);
2223        if (error)
2224            return error;
2225
2226    } else if (handle->cur <= nr_meta_pages + 1) {
2227        error = unpack_orig_pfns(buffer, &copy_bm);
2228        if (error)
2229            return error;
2230
2231        if (handle->cur == nr_meta_pages + 1) {
2232            error = prepare_image(&orig_bm, &copy_bm);
2233            if (error)
2234                return error;
2235
2236            chain_init(&ca, GFP_ATOMIC, PG_SAFE);
2237            memory_bm_position_reset(&orig_bm);
2238            restore_pblist = NULL;
2239            handle->buffer = get_buffer(&orig_bm, &ca);
2240            handle->sync_read = 0;
2241            if (IS_ERR(handle->buffer))
2242                return PTR_ERR(handle->buffer);
2243        }
2244    } else {
2245        copy_last_highmem_page();
2246        handle->buffer = get_buffer(&orig_bm, &ca);
2247        if (IS_ERR(handle->buffer))
2248            return PTR_ERR(handle->buffer);
2249        if (handle->buffer != buffer)
2250            handle->sync_read = 0;
2251    }
2252    handle->cur++;
2253    return PAGE_SIZE;
2254}
2255
2256/**
2257 * snapshot_write_finalize - must be called after the last call to
2258 * snapshot_write_next() in case the last page in the image happens
2259 * to be a highmem page and its contents should be stored in the
2260 * highmem. Additionally, it releases the memory that will not be
2261 * used any more.
2262 */
2263
2264void snapshot_write_finalize(struct snapshot_handle *handle)
2265{
2266    copy_last_highmem_page();
2267    /* Free only if we have loaded the image entirely */
2268    if (handle->cur > 1 && handle->cur > nr_meta_pages + nr_copy_pages) {
2269        memory_bm_free(&orig_bm, PG_UNSAFE_CLEAR);
2270        free_highmem_data();
2271    }
2272}
2273
2274int snapshot_image_loaded(struct snapshot_handle *handle)
2275{
2276    return !(!nr_copy_pages || !last_highmem_page_copied() ||
2277            handle->cur <= nr_meta_pages + nr_copy_pages);
2278}
2279
2280#ifdef CONFIG_HIGHMEM
2281/* Assumes that @buf is ready and points to a "safe" page */
2282static inline void
2283swap_two_pages_data(struct page *p1, struct page *p2, void *buf)
2284{
2285    void *kaddr1, *kaddr2;
2286
2287    kaddr1 = kmap_atomic(p1, KM_USER0);
2288    kaddr2 = kmap_atomic(p2, KM_USER1);
2289    copy_page(buf, kaddr1);
2290    copy_page(kaddr1, kaddr2);
2291    copy_page(kaddr2, buf);
2292    kunmap_atomic(kaddr2, KM_USER1);
2293    kunmap_atomic(kaddr1, KM_USER0);
2294}
2295
2296/**
2297 * restore_highmem - for each highmem page that was allocated before
2298 * the suspend and included in the suspend image, and also has been
2299 * allocated by the "resume" kernel swap its current (ie. "before
2300 * resume") contents with the previous (ie. "before suspend") one.
2301 *
2302 * If the resume eventually fails, we can call this function once
2303 * again and restore the "before resume" highmem state.
2304 */
2305
2306int restore_highmem(void)
2307{
2308    struct highmem_pbe *pbe = highmem_pblist;
2309    void *buf;
2310
2311    if (!pbe)
2312        return 0;
2313
2314    buf = get_image_page(GFP_ATOMIC, PG_SAFE);
2315    if (!buf)
2316        return -ENOMEM;
2317
2318    while (pbe) {
2319        swap_two_pages_data(pbe->copy_page, pbe->orig_page, buf);
2320        pbe = pbe->next;
2321    }
2322    free_image_page(buf, PG_UNSAFE_CLEAR);
2323    return 0;
2324}
2325#endif /* CONFIG_HIGHMEM */
2326

Archive Download this file



interactive