lkml.org 
[lkml]   [2010]   [Sep]   [25]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    From
    Subject[PATCH 11/22] Hibernation: Move block i/o fns to block_io.c
    Date
    Move the functions that specifically deal with submitting I/O
    to block_io.c. This helps us in working towards having a clean
    separation between swap specific functions (which will be all
    that will be in swap.c eventually) and low level block i/o
    functions (block_io.c) that are/will be agnostic with regard to
    the source of the storage. The block_io.c functions will thus
    also be useable when support for storing an image in a generic
    file (non swap) is added later.

    Signed-off-by: Nigel Cunningham <nigel@tuxonice.net>
    ---
    kernel/power/block_io.c | 199 ++++++++++++++++++++++++++++++++++++++++++++++
    kernel/power/block_io.h | 23 ++++++
    kernel/power/swap.c | 202 +++--------------------------------------------
    3 files changed, 235 insertions(+), 189 deletions(-)
    create mode 100644 kernel/power/block_io.h

    diff --git a/kernel/power/block_io.c b/kernel/power/block_io.c
    index aa239a2..5edcb08 100644
    --- a/kernel/power/block_io.c
    +++ b/kernel/power/block_io.c
    @@ -13,6 +13,7 @@
    #include <linux/swap.h>

    #include "power.h"
    +#include "extents.h"

    static struct bio *bio_chain;

    @@ -102,3 +103,201 @@ int hib_wait_on_bio_chain(void)
    bio_chain = NULL;
    return ret;
    }
    +
    +/*
    + * The swap map is a data structure used for keeping track of each page
    + * written to a swap partition. It consists of many swap_map_page
    + * structures that contain each an array of MAP_PAGE_SIZE swap entries.
    + * These structures are stored on the swap and linked together with the
    + * help of the .next_swap member.
    + *
    + * The swap map is created during suspend. The swap map pages are
    + * allocated and populated one at a time, so we only need one memory
    + * page to set up the entire structure.
    + *
    + * During resume we also only need to use one swap_map_page structure
    + * at a time.
    + */
    +
    +#define MAP_PAGE_ENTRIES (PAGE_SIZE / sizeof(sector_t) - 1)
    +
    +struct swap_map_page {
    + sector_t entries[MAP_PAGE_ENTRIES];
    + sector_t next_swap;
    +};
    +
    +/**
    + * The swap_map_handle structure is used for handling swap in
    + * a file-alike way
    + */
    +
    +struct swap_map_handle {
    + struct swap_map_page *cur;
    + sector_t cur_swap;
    + sector_t first_sector;
    + unsigned int k;
    +};
    +
    +static struct swap_map_handle handle;
    +
    +extern struct hib_extent_state sector_extents;
    +
    +/* Calculate the overhead needed for storing n pages */
    +unsigned int hib_bio_overhead(unsigned int nr_pages)
    +{
    + return DIV_ROUND_UP(nr_pages, MAP_PAGE_ENTRIES);
    +}
    +
    +/* Get the first sector of the image proper, for storing in the signature */
    +sector_t hib_get_first_sector(void)
    +{
    + return handle.first_sector;
    +}
    +
    +/**
    + * write_page - Write one page to given swap location.
    + * @buf: Address we're writing.
    + * @offset: Offset of the swap page we're writing to.
    + * @sync: Whether to force synchronous i/o.
    + */
    +
    +static int write_page(void *buf, sector_t offset, int sync)
    +{
    + void *src;
    +
    + if (!offset)
    + return -ENOSPC;
    +
    + if (!sync) {
    + src = (void *)__get_free_page(__GFP_WAIT | __GFP_HIGH);
    + if (src) {
    + memcpy(src, buf, PAGE_SIZE);
    + } else {
    + WARN_ON_ONCE(1);
    + sync = 1; /* Go synchronous */
    + src = buf;
    + }
    + } else {
    + src = buf;
    + }
    + return hib_bio_write_page(offset, src, sync);
    +}
    +
    +void release_swap_writer(void)
    +{
    + if (handle.cur)
    + free_page((unsigned long)handle.cur);
    + handle.cur = NULL;
    +}
    +
    +int hib_bio_prepare_write(void)
    +{
    + handle.cur = (struct swap_map_page *)get_zeroed_page(GFP_KERNEL);
    +
    + if (!handle.cur)
    + return -ENOMEM;
    +
    + handle.cur_swap = hib_extent_next(&sector_extents);
    +
    + if (!handle.cur_swap) {
    + release_swap_writer();
    + return -ENOSPC;
    + }
    +
    + handle.k = 0;
    + handle.first_sector = handle.cur_swap;
    + return 0;
    +}
    +
    +int swap_write_page(void *buf, int sync)
    +{
    + int error = 0;
    + sector_t offset;
    +
    + if (!handle.cur)
    + return -EINVAL;
    + offset = hib_extent_next(&sector_extents);
    + error = write_page(buf, offset, sync);
    + if (error)
    + return error;
    + handle.cur->entries[handle.k++] = offset;
    + if (handle.k >= MAP_PAGE_ENTRIES) {
    + error = hib_wait_on_bio_chain();
    + if (error)
    + goto out;
    + offset = hib_extent_next(&sector_extents);
    + if (!offset)
    + return -ENOSPC;
    + handle.cur->next_swap = offset;
    + error = write_page(handle.cur, handle.cur_swap, 1);
    + if (error)
    + goto out;
    + memset(handle.cur, 0, PAGE_SIZE);
    + handle.cur_swap = offset;
    + handle.k = 0;
    + }
    + out:
    + return error;
    +}
    +
    +int flush_swap_writer(void)
    +{
    + if (handle.cur && handle.cur_swap)
    + return write_page(handle.cur, handle.cur_swap, 1);
    + else
    + return -EINVAL;
    +}
    +
    +/**
    + * The following functions allow us to read data using a swap map
    + * in a file-alike way
    + */
    +
    +void release_swap_reader(void)
    +{
    + if (handle.cur)
    + free_page((unsigned long)handle.cur);
    + handle.cur = NULL;
    +}
    +
    +int get_swap_reader(unsigned int *flags_p, sector_t first_page)
    +{
    + int error;
    +
    + handle.cur = (struct swap_map_page *)get_zeroed_page(__GFP_WAIT | __GFP_HIGH);
    + if (!handle.cur)
    + return -ENOMEM;
    +
    + error = hib_bio_read_page(first_page, handle.cur, 1);
    + if (error) {
    + release_swap_reader();
    + return error;
    + }
    + handle.k = 0;
    + return 0;
    +}
    +
    +int swap_read_page(void *buf, int sync)
    +{
    + sector_t offset;
    + int error;
    +
    + if (!handle.cur)
    + return -EINVAL;
    + offset = handle.cur->entries[handle.k];
    + if (!offset)
    + return -EFAULT;
    + error = hib_bio_read_page(offset, buf, sync);
    + if (error)
    + return error;
    + if (++handle.k >= MAP_PAGE_ENTRIES) {
    + error = hib_wait_on_bio_chain();
    + handle.k = 0;
    + offset = handle.cur->next_swap;
    + if (!offset)
    + release_swap_reader();
    + else if (!error)
    + error = hib_bio_read_page(offset, handle.cur, 1);
    + }
    + return error;
    +}
    diff --git a/kernel/power/block_io.h b/kernel/power/block_io.h
    new file mode 100644
    index 0000000..2f91d6d
    --- /dev/null
    +++ b/kernel/power/block_io.h
    @@ -0,0 +1,23 @@
    +/*
    + * Copyright (C) 1998,2001-2005 Pavel Machek <pavel@ucw.cz>
    + * Copyright (C) 2006 Rafael J. Wysocki <rjw@sisk.pl>
    + * Copyright (C) 2010 Nigel Cunningham <nigel@tuxonice.net>
    + *
    + * This file is released under the GPLv2.
    + */
    +
    +/* Low level routines */
    +int hib_bio_read_page(pgoff_t page_off, void *addr, int sync);
    +int hib_bio_write_page(pgoff_t page_off, void *addr, int sync);
    +int hib_wait_on_bio_chain(void);
    +
    +unsigned int hib_bio_overhead(unsigned int nr_pages);
    +sector_t hib_get_first_sector(void);
    +extern struct hib_extent_state sector_extents;
    +void release_swap_writer(void);
    +int hib_bio_prepare_write(void);
    +int flush_swap_writer(void);
    +int swap_write_page(void *buf, int sync);
    +int get_swap_reader(unsigned int *flags_p, sector_t first_page);
    +void release_swap_reader(void);
    +int swap_read_page(void *buf, int sync);
    diff --git a/kernel/power/swap.c b/kernel/power/swap.c
    index a881086..d217a6f 100644
    --- a/kernel/power/swap.c
    +++ b/kernel/power/swap.c
    @@ -26,45 +26,10 @@

    #include "power.h"
    #include "extents.h"
    +#include "block_io.h"

    #define SWSUSP_SIG "S1SUSPEND"

    -/*
    - * The swap map is a data structure used for keeping track of each page
    - * written to a swap partition. It consists of many swap_map_page
    - * structures that contain each an array of MAP_PAGE_ENTRIES swap entries.
    - * These structures are stored on the swap and linked together with the
    - * help of the .next_swap member.
    - *
    - * The swap map is created during suspend. The swap map pages are
    - * allocated and populated one at a time, so we only need one memory
    - * page to set up the entire structure.
    - *
    - * During resume we also only need to use one swap_map_page structure
    - * at a time.
    - */
    -
    -#define MAP_PAGE_ENTRIES (PAGE_SIZE / sizeof(sector_t) - 1)
    -
    -struct swap_map_page {
    - sector_t entries[MAP_PAGE_ENTRIES];
    - sector_t next_swap;
    -};
    -
    -/**
    - * The swap_map_handle structure is used for handling swap in
    - * a file-alike way
    - */
    -
    -struct swap_map_handle {
    - struct swap_map_page *cur;
    - sector_t cur_swap;
    - sector_t first_sector;
    - unsigned int k;
    -};
    -
    -static struct swap_map_handle handle;
    -
    static unsigned short root_swap = 0xffff;

    struct swsusp_header {
    @@ -79,7 +44,7 @@ struct swsusp_header {
    static struct swsusp_header *swsusp_header;

    static struct hib_extent_state swap_extents;
    -static struct hib_extent_state sector_extents;
    +struct hib_extent_state sector_extents;

    /**
    * alloc_swapdev_block - allocate a swap page and register that it has
    @@ -127,7 +92,7 @@ static int allocate_swap(unsigned int nr_pages)
    {
    unsigned int free_swap = count_swap_pages(root_swap, 1);

    - nr_pages += DIV_ROUND_UP(nr_pages, MAP_PAGE_ENTRIES);
    + nr_pages += hib_bio_overhead(nr_pages);

    pr_debug("PM: Free swap pages: %u\n", free_swap);
    if (free_swap < nr_pages)
    @@ -185,7 +150,7 @@ static int mark_swapfiles(unsigned int flags)
    memcpy(swsusp_header->orig_sig,swsusp_header->sig, 10);
    memcpy(swsusp_header->sig,SWSUSP_SIG, 10);
    swsusp_header->write_speed = write_speed;
    - swsusp_header->image = handle.first_sector;
    + swsusp_header->image = hib_get_first_sector();
    swsusp_header->flags = flags;
    error = hib_bio_write_page(swsusp_resume_block,
    swsusp_header, 1);
    @@ -223,42 +188,6 @@ static int swsusp_swap_check(void)
    return res;
    }

    -/**
    - * write_page - Write one page to given swap location.
    - * @buf: Address we're writing.
    - * @offset: Offset of the swap page we're writing to.
    - * @sync: Whether to force synchronous i/o.
    - */
    -
    -static int write_page(void *buf, sector_t offset, int sync)
    -{
    - void *src;
    -
    - if (!offset)
    - return -ENOSPC;
    -
    - if (!sync) {
    - src = (void *)__get_free_page(__GFP_WAIT | __GFP_HIGH);
    - if (src) {
    - memcpy(src, buf, PAGE_SIZE);
    - } else {
    - WARN_ON_ONCE(1);
    - sync = 1; /* Go synchronous */
    - src = buf;
    - }
    - } else {
    - src = buf;
    - }
    - return hib_bio_write_page(offset, src, sync);
    -}
    -
    -static void release_swap_writer(void)
    -{
    - if (handle.cur)
    - free_page((unsigned long)handle.cur);
    - handle.cur = NULL;
    -}
    -
    static int get_swap_writer(unsigned long pages)
    {
    int ret;
    @@ -270,70 +199,19 @@ static int get_swap_writer(unsigned long pages)
    "swapon -a.\n");
    return ret;
    }
    - handle.cur = (struct swap_map_page *)get_zeroed_page(GFP_KERNEL);
    - if (!handle.cur) {
    - ret = -ENOMEM;
    - goto err_close;
    - }
    if (!allocate_swap(pages)) {
    printk(KERN_ERR "PM: Not enough free swap\n");
    ret = -ENOSPC;
    goto err_close;
    }
    - handle.cur_swap = hib_extent_next(&sector_extents);
    - if (!handle.cur_swap) {
    - ret = -ENOSPC;
    - goto err_rel;
    - }
    - handle.k = 0;
    - handle.first_sector = handle.cur_swap;
    - return 0;
    -err_rel:
    - release_swap_writer();
    + ret = hib_bio_prepare_write();
    + if (!ret)
    + return 0;
    err_close:
    swsusp_close(FMODE_WRITE);
    return ret;
    }

    -static int swap_write_page(void *buf, int sync)
    -{
    - int error = 0;
    - sector_t offset;
    -
    - if (!handle.cur)
    - return -EINVAL;
    - offset = hib_extent_next(&sector_extents);
    - error = write_page(buf, offset, sync);
    - if (error)
    - return error;
    - handle.cur->entries[handle.k++] = offset;
    - if (handle.k >= MAP_PAGE_ENTRIES) {
    - error = hib_wait_on_bio_chain();
    - if (error)
    - goto out;
    - offset = hib_extent_next(&sector_extents);
    - if (!offset)
    - return -ENOSPC;
    - handle.cur->next_swap = offset;
    - error = write_page(handle.cur, handle.cur_swap, 1);
    - if (error)
    - goto out;
    - memset(handle.cur, 0, PAGE_SIZE);
    - handle.cur_swap = offset;
    - handle.k = 0;
    - }
    - out:
    - return error;
    -}
    -
    -static int flush_swap_writer(void)
    -{
    - if (handle.cur && handle.cur_swap)
    - return write_page(handle.cur, handle.cur_swap, 1);
    - else
    - return -EINVAL;
    -}
    -
    static int swap_writer_finish(unsigned int flags, int error)
    {
    if (!error) {
    @@ -437,65 +315,6 @@ out_finish:
    return error;
    }

    -/**
    - * The following functions allow us to read data using a swap map
    - * in a file-alike way
    - */
    -
    -static void release_swap_reader(void)
    -{
    - if (handle.cur)
    - free_page((unsigned long)handle.cur);
    - handle.cur = NULL;
    -}
    -
    -static int get_swap_reader(unsigned int *flags_p)
    -{
    - int error;
    -
    - *flags_p = swsusp_header->flags;
    -
    - if (!swsusp_header->image) /* how can this happen? */
    - return -EINVAL;
    -
    - handle.cur = (struct swap_map_page *)get_zeroed_page(__GFP_WAIT | __GFP_HIGH);
    - if (!handle.cur)
    - return -ENOMEM;
    -
    - error = hib_bio_read_page(swsusp_header->image, handle.cur, 1);
    - if (error) {
    - release_swap_reader();
    - return error;
    - }
    - handle.k = 0;
    - return 0;
    -}
    -
    -static int swap_read_page(void *buf, int sync)
    -{
    - sector_t offset;
    - int error;
    -
    - if (!handle.cur)
    - return -EINVAL;
    - offset = handle.cur->entries[handle.k];
    - if (!offset)
    - return -EFAULT;
    - error = hib_bio_read_page(offset, buf, sync);
    - if (error)
    - return error;
    - if (++handle.k >= MAP_PAGE_ENTRIES) {
    - error = hib_wait_on_bio_chain();
    - handle.k = 0;
    - offset = handle.cur->next_swap;
    - if (!offset)
    - release_swap_reader();
    - else if (!error)
    - error = hib_bio_read_page(offset, handle.cur, 1);
    - }
    - return error;
    -}
    -
    static int swap_reader_finish(void)
    {
    release_swap_reader();
    @@ -574,7 +393,12 @@ int swsusp_read(unsigned int *flags_p)
    if (error < PAGE_SIZE)
    return error < 0 ? error : -EFAULT;
    header = (struct swsusp_info *)data_of(snapshot);
    - error = get_swap_reader(flags_p);
    + *flags_p = swsusp_header->flags;
    + if (!swsusp_header->image) { /* how can this happen? */
    + error = -EINVAL;
    + goto end;
    + }
    + error = get_swap_reader(flags_p, swsusp_header->image);
    if (error)
    goto end;
    if (!error)
    --
    1.7.0.4


    \
     
     \ /
      Last update: 2010-09-27 20:09    [W:0.052 / U:0.256 seconds]
    ©2003-2016 Jasper Spaans. hosted at Digital OceanAdvertise on this site