[PATCH] swsusp: low level interface
[linux-2.6.git] / kernel / power / snapshot.c
1 /*
2  * linux/kernel/power/snapshot.c
3  *
4  * This file provide system snapshot/restore functionality.
5  *
6  * Copyright (C) 1998-2005 Pavel Machek <pavel@suse.cz>
7  *
8  * This file is released under the GPLv2, and is based on swsusp.c.
9  *
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/smp_lock.h>
18 #include <linux/delay.h>
19 #include <linux/bitops.h>
20 #include <linux/spinlock.h>
21 #include <linux/kernel.h>
22 #include <linux/pm.h>
23 #include <linux/device.h>
24 #include <linux/bootmem.h>
25 #include <linux/syscalls.h>
26 #include <linux/console.h>
27 #include <linux/highmem.h>
28
29 #include <asm/uaccess.h>
30 #include <asm/mmu_context.h>
31 #include <asm/pgtable.h>
32 #include <asm/tlbflush.h>
33 #include <asm/io.h>
34
35 #include "power.h"
36
37 struct pbe *pagedir_nosave;
38 static unsigned int nr_copy_pages;
39 static unsigned int nr_meta_pages;
40
41 #ifdef CONFIG_HIGHMEM
42 unsigned int count_highmem_pages(void)
43 {
44         struct zone *zone;
45         unsigned long zone_pfn;
46         unsigned int n = 0;
47
48         for_each_zone (zone)
49                 if (is_highmem(zone)) {
50                         mark_free_pages(zone);
51                         for (zone_pfn = 0; zone_pfn < zone->spanned_pages; zone_pfn++) {
52                                 struct page *page;
53                                 unsigned long pfn = zone_pfn + zone->zone_start_pfn;
54                                 if (!pfn_valid(pfn))
55                                         continue;
56                                 page = pfn_to_page(pfn);
57                                 if (PageReserved(page))
58                                         continue;
59                                 if (PageNosaveFree(page))
60                                         continue;
61                                 n++;
62                         }
63                 }
64         return n;
65 }
66
67 struct highmem_page {
68         char *data;
69         struct page *page;
70         struct highmem_page *next;
71 };
72
73 static struct highmem_page *highmem_copy;
74
75 static int save_highmem_zone(struct zone *zone)
76 {
77         unsigned long zone_pfn;
78         mark_free_pages(zone);
79         for (zone_pfn = 0; zone_pfn < zone->spanned_pages; ++zone_pfn) {
80                 struct page *page;
81                 struct highmem_page *save;
82                 void *kaddr;
83                 unsigned long pfn = zone_pfn + zone->zone_start_pfn;
84
85                 if (!(pfn%1000))
86                         printk(".");
87                 if (!pfn_valid(pfn))
88                         continue;
89                 page = pfn_to_page(pfn);
90                 /*
91                  * This condition results from rvmalloc() sans vmalloc_32()
92                  * and architectural memory reservations. This should be
93                  * corrected eventually when the cases giving rise to this
94                  * are better understood.
95                  */
96                 if (PageReserved(page))
97                         continue;
98                 BUG_ON(PageNosave(page));
99                 if (PageNosaveFree(page))
100                         continue;
101                 save = kmalloc(sizeof(struct highmem_page), GFP_ATOMIC);
102                 if (!save)
103                         return -ENOMEM;
104                 save->next = highmem_copy;
105                 save->page = page;
106                 save->data = (void *) get_zeroed_page(GFP_ATOMIC);
107                 if (!save->data) {
108                         kfree(save);
109                         return -ENOMEM;
110                 }
111                 kaddr = kmap_atomic(page, KM_USER0);
112                 memcpy(save->data, kaddr, PAGE_SIZE);
113                 kunmap_atomic(kaddr, KM_USER0);
114                 highmem_copy = save;
115         }
116         return 0;
117 }
118
119 int save_highmem(void)
120 {
121         struct zone *zone;
122         int res = 0;
123
124         pr_debug("swsusp: Saving Highmem\n");
125         for_each_zone (zone) {
126                 if (is_highmem(zone))
127                         res = save_highmem_zone(zone);
128                 if (res)
129                         return res;
130         }
131         return 0;
132 }
133
134 int restore_highmem(void)
135 {
136         printk("swsusp: Restoring Highmem\n");
137         while (highmem_copy) {
138                 struct highmem_page *save = highmem_copy;
139                 void *kaddr;
140                 highmem_copy = save->next;
141
142                 kaddr = kmap_atomic(save->page, KM_USER0);
143                 memcpy(kaddr, save->data, PAGE_SIZE);
144                 kunmap_atomic(kaddr, KM_USER0);
145                 free_page((long) save->data);
146                 kfree(save);
147         }
148         return 0;
149 }
150 #endif
151
152 static int pfn_is_nosave(unsigned long pfn)
153 {
154         unsigned long nosave_begin_pfn = __pa(&__nosave_begin) >> PAGE_SHIFT;
155         unsigned long nosave_end_pfn = PAGE_ALIGN(__pa(&__nosave_end)) >> PAGE_SHIFT;
156         return (pfn >= nosave_begin_pfn) && (pfn < nosave_end_pfn);
157 }
158
159 /**
160  *      saveable - Determine whether a page should be cloned or not.
161  *      @pfn:   The page
162  *
163  *      We save a page if it's Reserved, and not in the range of pages
164  *      statically defined as 'unsaveable', or if it isn't reserved, and
165  *      isn't part of a free chunk of pages.
166  */
167
168 static int saveable(struct zone *zone, unsigned long *zone_pfn)
169 {
170         unsigned long pfn = *zone_pfn + zone->zone_start_pfn;
171         struct page *page;
172
173         if (!pfn_valid(pfn))
174                 return 0;
175
176         page = pfn_to_page(pfn);
177         BUG_ON(PageReserved(page) && PageNosave(page));
178         if (PageNosave(page))
179                 return 0;
180         if (PageReserved(page) && pfn_is_nosave(pfn))
181                 return 0;
182         if (PageNosaveFree(page))
183                 return 0;
184
185         return 1;
186 }
187
188 unsigned int count_data_pages(void)
189 {
190         struct zone *zone;
191         unsigned long zone_pfn;
192         unsigned int n = 0;
193
194         for_each_zone (zone) {
195                 if (is_highmem(zone))
196                         continue;
197                 mark_free_pages(zone);
198                 for (zone_pfn = 0; zone_pfn < zone->spanned_pages; ++zone_pfn)
199                         n += saveable(zone, &zone_pfn);
200         }
201         return n;
202 }
203
204 static void copy_data_pages(struct pbe *pblist)
205 {
206         struct zone *zone;
207         unsigned long zone_pfn;
208         struct pbe *pbe, *p;
209
210         pbe = pblist;
211         for_each_zone (zone) {
212                 if (is_highmem(zone))
213                         continue;
214                 mark_free_pages(zone);
215                 /* This is necessary for swsusp_free() */
216                 for_each_pb_page (p, pblist)
217                         SetPageNosaveFree(virt_to_page(p));
218                 for_each_pbe (p, pblist)
219                         SetPageNosaveFree(virt_to_page(p->address));
220                 for (zone_pfn = 0; zone_pfn < zone->spanned_pages; ++zone_pfn) {
221                         if (saveable(zone, &zone_pfn)) {
222                                 struct page *page;
223                                 page = pfn_to_page(zone_pfn + zone->zone_start_pfn);
224                                 BUG_ON(!pbe);
225                                 pbe->orig_address = (unsigned long)page_address(page);
226                                 /* copy_page is not usable for copying task structs. */
227                                 memcpy((void *)pbe->address, (void *)pbe->orig_address, PAGE_SIZE);
228                                 pbe = pbe->next;
229                         }
230                 }
231         }
232         BUG_ON(pbe);
233 }
234
235
236 /**
237  *      free_pagedir - free pages allocated with alloc_pagedir()
238  */
239
240 static void free_pagedir(struct pbe *pblist)
241 {
242         struct pbe *pbe;
243
244         while (pblist) {
245                 pbe = (pblist + PB_PAGE_SKIP)->next;
246                 ClearPageNosave(virt_to_page(pblist));
247                 ClearPageNosaveFree(virt_to_page(pblist));
248                 free_page((unsigned long)pblist);
249                 pblist = pbe;
250         }
251 }
252
253 /**
254  *      fill_pb_page - Create a list of PBEs on a given memory page
255  */
256
257 static inline void fill_pb_page(struct pbe *pbpage)
258 {
259         struct pbe *p;
260
261         p = pbpage;
262         pbpage += PB_PAGE_SKIP;
263         do
264                 p->next = p + 1;
265         while (++p < pbpage);
266 }
267
268 /**
269  *      create_pbe_list - Create a list of PBEs on top of a given chain
270  *      of memory pages allocated with alloc_pagedir()
271  */
272
273 static inline void create_pbe_list(struct pbe *pblist, unsigned int nr_pages)
274 {
275         struct pbe *pbpage, *p;
276         unsigned int num = PBES_PER_PAGE;
277
278         for_each_pb_page (pbpage, pblist) {
279                 if (num >= nr_pages)
280                         break;
281
282                 fill_pb_page(pbpage);
283                 num += PBES_PER_PAGE;
284         }
285         if (pbpage) {
286                 for (num -= PBES_PER_PAGE - 1, p = pbpage; num < nr_pages; p++, num++)
287                         p->next = p + 1;
288                 p->next = NULL;
289         }
290 }
291
292 /**
293  *      On resume it is necessary to trace and eventually free the unsafe
294  *      pages that have been allocated, because they are needed for I/O
295  *      (on x86-64 we likely will "eat" these pages once again while
296  *      creating the temporary page translation tables)
297  */
298
299 struct eaten_page {
300         struct eaten_page *next;
301         char padding[PAGE_SIZE - sizeof(void *)];
302 };
303
304 static struct eaten_page *eaten_pages = NULL;
305
306 static void release_eaten_pages(void)
307 {
308         struct eaten_page *p, *q;
309
310         p = eaten_pages;
311         while (p) {
312                 q = p->next;
313                 /* We don't want swsusp_free() to free this page again */
314                 ClearPageNosave(virt_to_page(p));
315                 free_page((unsigned long)p);
316                 p = q;
317         }
318         eaten_pages = NULL;
319 }
320
321 /**
322  *      @safe_needed - on resume, for storing the PBE list and the image,
323  *      we can only use memory pages that do not conflict with the pages
324  *      which had been used before suspend.
325  *
326  *      The unsafe pages are marked with the PG_nosave_free flag
327  *
328  *      Allocated but unusable (ie eaten) memory pages should be marked
329  *      so that swsusp_free() can release them
330  */
331
332 static inline void *alloc_image_page(gfp_t gfp_mask, int safe_needed)
333 {
334         void *res;
335
336         if (safe_needed)
337                 do {
338                         res = (void *)get_zeroed_page(gfp_mask);
339                         if (res && PageNosaveFree(virt_to_page(res))) {
340                                 /* This is for swsusp_free() */
341                                 SetPageNosave(virt_to_page(res));
342                                 ((struct eaten_page *)res)->next = eaten_pages;
343                                 eaten_pages = res;
344                         }
345                 } while (res && PageNosaveFree(virt_to_page(res)));
346         else
347                 res = (void *)get_zeroed_page(gfp_mask);
348         if (res) {
349                 SetPageNosave(virt_to_page(res));
350                 SetPageNosaveFree(virt_to_page(res));
351         }
352         return res;
353 }
354
355 unsigned long get_safe_page(gfp_t gfp_mask)
356 {
357         return (unsigned long)alloc_image_page(gfp_mask, 1);
358 }
359
360 /**
361  *      alloc_pagedir - Allocate the page directory.
362  *
363  *      First, determine exactly how many pages we need and
364  *      allocate them.
365  *
366  *      We arrange the pages in a chain: each page is an array of PBES_PER_PAGE
367  *      struct pbe elements (pbes) and the last element in the page points
368  *      to the next page.
369  *
370  *      On each page we set up a list of struct_pbe elements.
371  */
372
373 struct pbe *alloc_pagedir(unsigned int nr_pages, gfp_t gfp_mask, int safe_needed)
374 {
375         unsigned int num;
376         struct pbe *pblist, *pbe;
377
378         if (!nr_pages)
379                 return NULL;
380
381         pblist = alloc_image_page(gfp_mask, safe_needed);
382         /* FIXME: rewrite this ugly loop */
383         for (pbe = pblist, num = PBES_PER_PAGE; pbe && num < nr_pages;
384                         pbe = pbe->next, num += PBES_PER_PAGE) {
385                 pbe += PB_PAGE_SKIP;
386                 pbe->next = alloc_image_page(gfp_mask, safe_needed);
387         }
388         if (!pbe) { /* get_zeroed_page() failed */
389                 free_pagedir(pblist);
390                 pblist = NULL;
391         } else
392                 create_pbe_list(pblist, nr_pages);
393         return pblist;
394 }
395
396 /**
397  * Free pages we allocated for suspend. Suspend pages are alocated
398  * before atomic copy, so we need to free them after resume.
399  */
400
401 void swsusp_free(void)
402 {
403         struct zone *zone;
404         unsigned long zone_pfn;
405
406         for_each_zone(zone) {
407                 for (zone_pfn = 0; zone_pfn < zone->spanned_pages; ++zone_pfn)
408                         if (pfn_valid(zone_pfn + zone->zone_start_pfn)) {
409                                 struct page *page;
410                                 page = pfn_to_page(zone_pfn + zone->zone_start_pfn);
411                                 if (PageNosave(page) && PageNosaveFree(page)) {
412                                         ClearPageNosave(page);
413                                         ClearPageNosaveFree(page);
414                                         free_page((long) page_address(page));
415                                 }
416                         }
417         }
418         nr_copy_pages = 0;
419         nr_meta_pages = 0;
420         pagedir_nosave = NULL;
421 }
422
423
424 /**
425  *      enough_free_mem - Make sure we enough free memory to snapshot.
426  *
427  *      Returns TRUE or FALSE after checking the number of available
428  *      free pages.
429  */
430
431 static int enough_free_mem(unsigned int nr_pages)
432 {
433         struct zone *zone;
434         unsigned int n = 0;
435
436         for_each_zone (zone)
437                 if (!is_highmem(zone))
438                         n += zone->free_pages;
439         pr_debug("swsusp: available memory: %u pages\n", n);
440         return n > (nr_pages + PAGES_FOR_IO +
441                 (nr_pages + PBES_PER_PAGE - 1) / PBES_PER_PAGE);
442 }
443
444 static int alloc_data_pages(struct pbe *pblist, gfp_t gfp_mask, int safe_needed)
445 {
446         struct pbe *p;
447
448         for_each_pbe (p, pblist) {
449                 p->address = (unsigned long)alloc_image_page(gfp_mask, safe_needed);
450                 if (!p->address)
451                         return -ENOMEM;
452         }
453         return 0;
454 }
455
456 static struct pbe *swsusp_alloc(unsigned int nr_pages)
457 {
458         struct pbe *pblist;
459
460         if (!(pblist = alloc_pagedir(nr_pages, GFP_ATOMIC | __GFP_COLD, 0))) {
461                 printk(KERN_ERR "suspend: Allocating pagedir failed.\n");
462                 return NULL;
463         }
464
465         if (alloc_data_pages(pblist, GFP_ATOMIC | __GFP_COLD, 0)) {
466                 printk(KERN_ERR "suspend: Allocating image pages failed.\n");
467                 swsusp_free();
468                 return NULL;
469         }
470
471         return pblist;
472 }
473
474 asmlinkage int swsusp_save(void)
475 {
476         unsigned int nr_pages;
477
478         pr_debug("swsusp: critical section: \n");
479
480         drain_local_pages();
481         nr_pages = count_data_pages();
482         printk("swsusp: Need to copy %u pages\n", nr_pages);
483
484         pr_debug("swsusp: pages needed: %u + %lu + %u, free: %u\n",
485                  nr_pages,
486                  (nr_pages + PBES_PER_PAGE - 1) / PBES_PER_PAGE,
487                  PAGES_FOR_IO, nr_free_pages());
488
489         if (!enough_free_mem(nr_pages)) {
490                 printk(KERN_ERR "swsusp: Not enough free memory\n");
491                 return -ENOMEM;
492         }
493
494         pagedir_nosave = swsusp_alloc(nr_pages);
495         if (!pagedir_nosave)
496                 return -ENOMEM;
497
498         /* During allocating of suspend pagedir, new cold pages may appear.
499          * Kill them.
500          */
501         drain_local_pages();
502         copy_data_pages(pagedir_nosave);
503
504         /*
505          * End of critical section. From now on, we can write to memory,
506          * but we should not touch disk. This specially means we must _not_
507          * touch swap space! Except we must write out our image of course.
508          */
509
510         nr_copy_pages = nr_pages;
511         nr_meta_pages = (nr_pages * sizeof(long) + PAGE_SIZE - 1) >> PAGE_SHIFT;
512
513         printk("swsusp: critical section/: done (%d pages copied)\n", nr_pages);
514         return 0;
515 }
516
517 static void init_header(struct swsusp_info *info)
518 {
519         memset(info, 0, sizeof(struct swsusp_info));
520         info->version_code = LINUX_VERSION_CODE;
521         info->num_physpages = num_physpages;
522         memcpy(&info->uts, &system_utsname, sizeof(system_utsname));
523         info->cpus = num_online_cpus();
524         info->image_pages = nr_copy_pages;
525         info->pages = nr_copy_pages + nr_meta_pages + 1;
526 }
527
528 /**
529  *      pack_orig_addresses - the .orig_address fields of the PBEs from the
530  *      list starting at @pbe are stored in the array @buf[] (1 page)
531  */
532
533 static inline struct pbe *pack_orig_addresses(unsigned long *buf, struct pbe *pbe)
534 {
535         int j;
536
537         for (j = 0; j < PAGE_SIZE / sizeof(long) && pbe; j++) {
538                 buf[j] = pbe->orig_address;
539                 pbe = pbe->next;
540         }
541         if (!pbe)
542                 for (; j < PAGE_SIZE / sizeof(long); j++)
543                         buf[j] = 0;
544         return pbe;
545 }
546
547 /**
548  *      snapshot_read_next - used for reading the system memory snapshot.
549  *
550  *      On the first call to it @handle should point to a zeroed
551  *      snapshot_handle structure.  The structure gets updated and a pointer
552  *      to it should be passed to this function every next time.
553  *
554  *      The @count parameter should contain the number of bytes the caller
555  *      wants to read from the snapshot.  It must not be zero.
556  *
557  *      On success the function returns a positive number.  Then, the caller
558  *      is allowed to read up to the returned number of bytes from the memory
559  *      location computed by the data_of() macro.  The number returned
560  *      may be smaller than @count, but this only happens if the read would
561  *      cross a page boundary otherwise.
562  *
563  *      The function returns 0 to indicate the end of data stream condition,
564  *      and a negative number is returned on error.  In such cases the
565  *      structure pointed to by @handle is not updated and should not be used
566  *      any more.
567  */
568
569 int snapshot_read_next(struct snapshot_handle *handle, size_t count)
570 {
571         static unsigned long *buffer;
572
573         if (handle->page > nr_meta_pages + nr_copy_pages)
574                 return 0;
575         if (!buffer) {
576                 /* This makes the buffer be freed by swsusp_free() */
577                 buffer = alloc_image_page(GFP_ATOMIC, 0);
578                 if (!buffer)
579                         return -ENOMEM;
580         }
581         if (!handle->offset) {
582                 init_header((struct swsusp_info *)buffer);
583                 handle->buffer = buffer;
584                 handle->pbe = pagedir_nosave;
585         }
586         if (handle->prev < handle->page) {
587                 if (handle->page <= nr_meta_pages) {
588                         handle->pbe = pack_orig_addresses(buffer, handle->pbe);
589                         if (!handle->pbe)
590                                 handle->pbe = pagedir_nosave;
591                 } else {
592                         handle->buffer = (void *)handle->pbe->address;
593                         handle->pbe = handle->pbe->next;
594                 }
595                 handle->prev = handle->page;
596         }
597         handle->buf_offset = handle->page_offset;
598         if (handle->page_offset + count >= PAGE_SIZE) {
599                 count = PAGE_SIZE - handle->page_offset;
600                 handle->page_offset = 0;
601                 handle->page++;
602         } else {
603                 handle->page_offset += count;
604         }
605         handle->offset += count;
606         return count;
607 }
608
609 /**
610  *      mark_unsafe_pages - mark the pages that cannot be used for storing
611  *      the image during resume, because they conflict with the pages that
612  *      had been used before suspend
613  */
614
615 static int mark_unsafe_pages(struct pbe *pblist)
616 {
617         struct zone *zone;
618         unsigned long zone_pfn;
619         struct pbe *p;
620
621         if (!pblist) /* a sanity check */
622                 return -EINVAL;
623
624         /* Clear page flags */
625         for_each_zone (zone) {
626                 for (zone_pfn = 0; zone_pfn < zone->spanned_pages; ++zone_pfn)
627                         if (pfn_valid(zone_pfn + zone->zone_start_pfn))
628                                 ClearPageNosaveFree(pfn_to_page(zone_pfn +
629                                         zone->zone_start_pfn));
630         }
631
632         /* Mark orig addresses */
633         for_each_pbe (p, pblist) {
634                 if (virt_addr_valid(p->orig_address))
635                         SetPageNosaveFree(virt_to_page(p->orig_address));
636                 else
637                         return -EFAULT;
638         }
639
640         return 0;
641 }
642
643 static void copy_page_backup_list(struct pbe *dst, struct pbe *src)
644 {
645         /* We assume both lists contain the same number of elements */
646         while (src) {
647                 dst->orig_address = src->orig_address;
648                 dst = dst->next;
649                 src = src->next;
650         }
651 }
652
653 static int check_header(struct swsusp_info *info)
654 {
655         char *reason = NULL;
656
657         if (info->version_code != LINUX_VERSION_CODE)
658                 reason = "kernel version";
659         if (info->num_physpages != num_physpages)
660                 reason = "memory size";
661         if (strcmp(info->uts.sysname,system_utsname.sysname))
662                 reason = "system type";
663         if (strcmp(info->uts.release,system_utsname.release))
664                 reason = "kernel release";
665         if (strcmp(info->uts.version,system_utsname.version))
666                 reason = "version";
667         if (strcmp(info->uts.machine,system_utsname.machine))
668                 reason = "machine";
669         if (reason) {
670                 printk(KERN_ERR "swsusp: Resume mismatch: %s\n", reason);
671                 return -EPERM;
672         }
673         return 0;
674 }
675
676 /**
677  *      load header - check the image header and copy data from it
678  */
679
680 static int load_header(struct snapshot_handle *handle,
681                               struct swsusp_info *info)
682 {
683         int error;
684         struct pbe *pblist;
685
686         error = check_header(info);
687         if (!error) {
688                 pblist = alloc_pagedir(info->image_pages, GFP_ATOMIC, 0);
689                 if (!pblist)
690                         return -ENOMEM;
691                 pagedir_nosave = pblist;
692                 handle->pbe = pblist;
693                 nr_copy_pages = info->image_pages;
694                 nr_meta_pages = info->pages - info->image_pages - 1;
695         }
696         return error;
697 }
698
699 /**
700  *      unpack_orig_addresses - copy the elements of @buf[] (1 page) to
701  *      the PBEs in the list starting at @pbe
702  */
703
704 static inline struct pbe *unpack_orig_addresses(unsigned long *buf,
705                                                 struct pbe *pbe)
706 {
707         int j;
708
709         for (j = 0; j < PAGE_SIZE / sizeof(long) && pbe; j++) {
710                 pbe->orig_address = buf[j];
711                 pbe = pbe->next;
712         }
713         return pbe;
714 }
715
716 /**
717  *      create_image - use metadata contained in the PBE list
718  *      pointed to by pagedir_nosave to mark the pages that will
719  *      be overwritten in the process of restoring the system
720  *      memory state from the image and allocate memory for
721  *      the image avoiding these pages
722  */
723
724 static int create_image(struct snapshot_handle *handle)
725 {
726         int error = 0;
727         struct pbe *p, *pblist;
728
729         p = pagedir_nosave;
730         error = mark_unsafe_pages(p);
731         if (!error) {
732                 pblist = alloc_pagedir(nr_copy_pages, GFP_ATOMIC, 1);
733                 if (pblist)
734                         copy_page_backup_list(pblist, p);
735                 free_pagedir(p);
736                 if (!pblist)
737                         error = -ENOMEM;
738         }
739         if (!error)
740                 error = alloc_data_pages(pblist, GFP_ATOMIC, 1);
741         if (!error) {
742                 release_eaten_pages();
743                 pagedir_nosave = pblist;
744         } else {
745                 pagedir_nosave = NULL;
746                 handle->pbe = NULL;
747                 nr_copy_pages = 0;
748                 nr_meta_pages = 0;
749         }
750         return error;
751 }
752
753 /**
754  *      snapshot_write_next - used for writing the system memory snapshot.
755  *
756  *      On the first call to it @handle should point to a zeroed
757  *      snapshot_handle structure.  The structure gets updated and a pointer
758  *      to it should be passed to this function every next time.
759  *
760  *      The @count parameter should contain the number of bytes the caller
761  *      wants to write to the image.  It must not be zero.
762  *
763  *      On success the function returns a positive number.  Then, the caller
764  *      is allowed to write up to the returned number of bytes to the memory
765  *      location computed by the data_of() macro.  The number returned
766  *      may be smaller than @count, but this only happens if the write would
767  *      cross a page boundary otherwise.
768  *
769  *      The function returns 0 to indicate the "end of file" condition,
770  *      and a negative number is returned on error.  In such cases the
771  *      structure pointed to by @handle is not updated and should not be used
772  *      any more.
773  */
774
775 int snapshot_write_next(struct snapshot_handle *handle, size_t count)
776 {
777         static unsigned long *buffer;
778         int error = 0;
779
780         if (handle->prev && handle->page > nr_meta_pages + nr_copy_pages)
781                 return 0;
782         if (!buffer) {
783                 /* This makes the buffer be freed by swsusp_free() */
784                 buffer = alloc_image_page(GFP_ATOMIC, 0);
785                 if (!buffer)
786                         return -ENOMEM;
787         }
788         if (!handle->offset)
789                 handle->buffer = buffer;
790         if (handle->prev < handle->page) {
791                 if (!handle->prev) {
792                         error = load_header(handle, (struct swsusp_info *)buffer);
793                         if (error)
794                                 return error;
795                 } else if (handle->prev <= nr_meta_pages) {
796                         handle->pbe = unpack_orig_addresses(buffer, handle->pbe);
797                         if (!handle->pbe) {
798                                 error = create_image(handle);
799                                 if (error)
800                                         return error;
801                                 handle->pbe = pagedir_nosave;
802                                 handle->buffer = (void *)handle->pbe->address;
803                         }
804                 } else {
805                         handle->pbe = handle->pbe->next;
806                         handle->buffer = (void *)handle->pbe->address;
807                 }
808                 handle->prev = handle->page;
809         }
810         handle->buf_offset = handle->page_offset;
811         if (handle->page_offset + count >= PAGE_SIZE) {
812                 count = PAGE_SIZE - handle->page_offset;
813                 handle->page_offset = 0;
814                 handle->page++;
815         } else {
816                 handle->page_offset += count;
817         }
818         handle->offset += count;
819         return count;
820 }
821
822 int snapshot_image_loaded(struct snapshot_handle *handle)
823 {
824         return !(!handle->pbe || handle->pbe->next || !nr_copy_pages ||
825                 handle->page <= nr_meta_pages + nr_copy_pages);
826 }