static int suspend_prepare_image(void) { int error; pr_debug("swsusp: critical section: \n"); if (save_highmem()) { printk(KERN_CRIT "Suspend machine: Not enough free pages for highmem\n"); restore_highmem(); return -ENOMEM; } drain_local_pages(); count_data_pages(); printk("swsusp: Need to copy %u pages\n",nr_copy_pages); error = swsusp_alloc(); if (error) return error; /* During allocating of suspend pagedir, new cold pages may appear. * Kill them. */ drain_local_pages(); copy_data_pages(); /* * End of critical section. From now on, we can write to memory, * but we should not touch disk. This specially means we must _not_ * touch swap space! Except we must write out our image of course. */ printk("swsusp: critical section/: done (%d pages copied)\n", nr_copy_pages ); return 0; }
int pmdisk_suspend(void) { int error = 0; if ((error = read_swapfiles())) return error; drain_local_pages(); pm_pagedir_nosave = NULL; pr_debug("pmdisk: Counting pages to copy.\n" ); count_pages(); pr_debug("pmdisk: (pages needed: %d + %d free: %d)\n", pmdisk_pages,PAGES_FOR_IO,nr_free_pages()); if (!enough_free_mem()) return -ENOMEM; if (!enough_swap()) return -ENOSPC; if ((error = alloc_pagedir())) { pr_debug("pmdisk: Allocating pagedir failed.\n"); return error; } if ((error = alloc_image_pages())) { pr_debug("pmdisk: Allocating image pages failed.\n"); free_pagedir(); return error; } nr_copy_pages_check = pmdisk_pages; pagedir_order_check = pagedir_order; /* During allocating of suspend pagedir, new cold pages may appear. * Kill them */ drain_local_pages(); /* copy */ copy_pages(); /* * End of critical section. From now on, we can write to memory, * but we should not touch disk. This specially means we must _not_ * touch swap space! Except we must write out our image of course. */ pr_debug("pmdisk: %d pages copied\n", pmdisk_pages ); return 0; }
static int suspend_prepare_image(void) { struct sysinfo i; unsigned int nr_needed_pages = 0; drain_local_pages(); pagedir_nosave = NULL; printk( "/critical section: Counting pages to copy" ); nr_copy_pages = count_and_copy_data_pages(NULL); nr_needed_pages = nr_copy_pages + PAGES_FOR_IO; printk(" (pages needed: %d+%d=%d free: %d)\n",nr_copy_pages,PAGES_FOR_IO,nr_needed_pages,nr_free_pages()); if(nr_free_pages() < nr_needed_pages) { printk(KERN_CRIT "%sCouldn't get enough free pages, on %d pages short\n", name_suspend, nr_needed_pages-nr_free_pages()); root_swap = 0xFFFF; return 1; } si_swapinfo(&i); /* FIXME: si_swapinfo(&i) returns all swap devices information. We should only consider resume_device. */ if (i.freeswap < nr_needed_pages) { printk(KERN_CRIT "%sThere's not enough swap space available, on %ld pages short\n", name_suspend, nr_needed_pages-i.freeswap); return 1; } PRINTK( "Alloc pagedir\n" ); pagedir_save = pagedir_nosave = create_suspend_pagedir(nr_copy_pages); if(!pagedir_nosave) { /* Shouldn't happen */ printk(KERN_CRIT "%sCouldn't allocate enough pages\n",name_suspend); panic("Really should not happen"); return 1; } nr_copy_pages_check = nr_copy_pages; pagedir_order_check = pagedir_order; drain_local_pages(); /* During allocating of suspend pagedir, new cold pages may appear. Kill them */ if (nr_copy_pages != count_and_copy_data_pages(pagedir_nosave)) /* copy */ BUG(); /* * End of critical section. From now on, we can write to memory, * but we should not touch disk. This specially means we must _not_ * touch swap space! Except we must write out our image of course. */ printk( "critical section/: done (%d pages copied)\n", nr_copy_pages ); return 0; }
asmlinkage int swsusp_save(void) { unsigned int nr_pages; pr_debug("swsusp: critical section: \n"); drain_local_pages(); nr_pages = count_data_pages(); printk("swsusp: Need to copy %u pages\n", nr_pages); if (!enough_free_mem(nr_pages)) { printk(KERN_ERR "swsusp: Not enough free memory\n"); return -ENOMEM; } if (swsusp_alloc(&orig_bm, ©_bm, nr_pages)) return -ENOMEM; /* During allocating of suspend pagedir, new cold pages may appear. * Kill them. */ drain_local_pages(); copy_data_pages(©_bm, &orig_bm); /* * End of critical section. From now on, we can write to memory, * but we should not touch disk. This specially means we must _not_ * touch swap space! Except we must write out our image of course. */ nr_copy_pages = nr_pages; nr_meta_pages = (nr_pages * sizeof(long) + PAGE_SIZE - 1) >> PAGE_SHIFT; printk("swsusp: critical section/: done (%d pages copied)\n", nr_pages); return 0; }
int save_highmem(void) { struct zone *zone; int res = 0; pr_debug("swsusp: Saving Highmem"); drain_local_pages(); for_each_zone (zone) { if (is_highmem(zone)) res = save_highmem_zone(zone); if (res) return res; } printk("\n"); return 0; }