lkml.org 
[lkml]   [2010]   [Jun]   [2]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    From
    Subject[PATCH 06/21] Hibernation: Generic extents support.
    Date
    Separate out the extent storage and manipulation into a separate
    file and make them more generic, so we can also use extents for
    recording what sectors are used and (later) support multiple
    storage devices more easily.

    Signed-off-by: Nigel Cunningham <nigel@tuxonice.net>
    ---
    kernel/power/Makefile | 2 +-
    kernel/power/extents.c | 125 ++++++++++++++++++++++++++++++++++++++++++++++++
    kernel/power/extents.h | 35 +++++++++++++
    kernel/power/swap.c | 117 +++++---------------------------------------
    4 files changed, 175 insertions(+), 104 deletions(-)
    create mode 100644 kernel/power/extents.c
    create mode 100644 kernel/power/extents.h

    diff --git a/kernel/power/Makefile b/kernel/power/Makefile
    index 524e058..eac3541 100644
    --- a/kernel/power/Makefile
    +++ b/kernel/power/Makefile
    @@ -9,7 +9,7 @@ obj-$(CONFIG_FREEZER) += process.o
    obj-$(CONFIG_SUSPEND) += suspend.o
    obj-$(CONFIG_PM_TEST_SUSPEND) += suspend_test.o
    obj-$(CONFIG_HIBERNATION) += hibernate.o snapshot.o swap.o user.o \
    - block_io.o
    + block_io.o extents.o
    obj-$(CONFIG_HIBERNATION_NVS) += hibernate_nvs.o

    obj-$(CONFIG_MAGIC_SYSRQ) += poweroff.o
    diff --git a/kernel/power/extents.c b/kernel/power/extents.c
    new file mode 100644
    index 0000000..172322d
    --- /dev/null
    +++ b/kernel/power/extents.c
    @@ -0,0 +1,125 @@
    +/*
    + * linux/kernel/power/extents.c
    + *
    + * This file provides functions for storing and using a series of
    + * extents.
    + *
    + * Copyright (C) 1998,2001-2005 Pavel Machek <pavel@suse.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.
    + *
    + */
    +
    +#include <linux/slab.h>
    +#include "extents.h"
    +
    +int hib_extents_empty(struct hib_extent_state *pos)
    +{
    + return RB_EMPTY_ROOT(&pos->root);
    +}
    +
    +void hib_reset_extent_pos(struct hib_extent_state *pos)
    +{
    + if (hib_extents_empty(pos))
    + return;
    +
    + pos->node = rb_first(&pos->root);
    +
    + if (!pos->node) {
    + pos->cur_ext = NULL;
    + pos->offset = 0;
    + return;
    + }
    +
    + pos->cur_ext = container_of(pos->node, struct hib_extent, node);
    + pos->offset = pos->cur_ext->start;
    +}
    +
    +unsigned long hib_extent_current(struct hib_extent_state *pos)
    +{
    + return (pos->node) ? pos->offset : 0;
    +}
    +
    +unsigned long hib_extent_next(struct hib_extent_state *pos)
    +{
    + if (!pos->node)
    + return 0;
    +
    + if (pos->cur_ext->end >= pos->offset)
    + return pos->offset++;
    +
    + pos->node = rb_next(pos->node);
    + if (!pos->node)
    + return 0;
    +
    + pos->cur_ext = container_of(pos->node, struct hib_extent, node);
    + pos->offset = pos->cur_ext->start;
    + return pos->offset;
    +}
    +
    +int hib_extents_insert(struct hib_extent_state *pos, unsigned long value)
    +{
    + struct rb_node **new = &(pos->root.rb_node);
    + struct rb_node *parent = NULL;
    + struct hib_extent *ext;
    +
    + /* Figure out where to put the new node */
    + while (*new) {
    + ext = container_of(*new, struct hib_extent, node);
    + parent = *new;
    + if (value < ext->start) {
    + /* Try to merge */
    + if (value == ext->start - 1) {
    + ext->start--;
    + return 0;
    + }
    + new = &((*new)->rb_left);
    + } else if (value > ext->end) {
    + /* Try to merge */
    + if (value == ext->end + 1) {
    + ext->end++;
    + return 0;
    + }
    + new = &((*new)->rb_right);
    + } else {
    + /* It already is in the tree */
    + return -EINVAL;
    + }
    + }
    + /* Add the new node and rebalance the tree. */
    + ext = kzalloc(sizeof(struct hib_extent), GFP_KERNEL);
    + if (!ext)
    + return -ENOMEM;
    +
    + ext->start = value;
    + ext->end = value;
    + rb_link_node(&ext->node, parent, new);
    + rb_insert_color(&ext->node, &pos->root);
    + pos->num_extents++;
    + return 0;
    +}
    +
    +/**
    + * free_all_swap_pages - free swap pages allocated for saving image data.
    + * It also frees the extents used to register which swap entres had been
    + * allocated.
    + */
    +
    +void hib_extents_clear(struct hib_extent_state *pos)
    +{
    + struct rb_node *node;
    +
    + if (hib_extents_empty(pos))
    + return;
    +
    + while ((node = pos->root.rb_node)) {
    + struct hib_extent *ext;
    +
    + ext = container_of(node, struct hib_extent, node);
    + rb_erase(node, &pos->root);
    + pos->num_extents--;
    + kfree(ext);
    + }
    +}
    diff --git a/kernel/power/extents.h b/kernel/power/extents.h
    new file mode 100644
    index 0000000..0b69b8e
    --- /dev/null
    +++ b/kernel/power/extents.h
    @@ -0,0 +1,35 @@
    +/*
    + * linux/kernel/power/extents.h
    + *
    + * Copyright (C) 2010 Nigel Cunningham <nigel@tuxonice.net>
    + *
    + * This file is released under the GPLv2.
    + *
    + */
    +
    +#include <linux/rbtree.h>
    +
    +struct hib_extent {
    + struct rb_node node;
    + unsigned long start;
    + unsigned long end;
    +};
    +
    +struct hib_extent_state {
    + /* Tree */
    + struct rb_root root;
    + int num_extents;
    +
    + /* Current position */
    + struct rb_node *node;
    + struct hib_extent *cur_ext;
    + unsigned long offset;
    +};
    +
    +
    +void hib_reset_extent_pos(struct hib_extent_state *pos);
    +unsigned long hib_extent_current(struct hib_extent_state *pos);
    +unsigned long hib_extent_next(struct hib_extent_state *pos);
    +int hib_extents_insert(struct hib_extent_state *pos, unsigned long value);
    +void hib_extents_clear(struct hib_extent_state *pos);
    +int hib_extents_empty(struct hib_extent_state *pos);
    diff --git a/kernel/power/swap.c b/kernel/power/swap.c
    index 1e6e5b6..15cbe70 100644
    --- a/kernel/power/swap.c
    +++ b/kernel/power/swap.c
    @@ -23,9 +23,9 @@
    #include <linux/swap.h>
    #include <linux/swapops.h>
    #include <linux/pm.h>
    -#include <linux/slab.h>

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

    #define SWSUSP_SIG "S1SUSPEND"

    @@ -75,97 +75,14 @@ struct swsusp_header {

    static struct swsusp_header *swsusp_header;

    -/**
    - * The following functions are used for tracing the allocated
    - * swap pages, so that they can be freed in case of an error.
    - */
    -
    -struct swsusp_extent {
    - struct rb_node node;
    - unsigned long start;
    - unsigned long end;
    -};
    -
    -static struct rb_root swsusp_extents = RB_ROOT;
    -
    -struct storage_position {
    - struct rb_node *node;
    - struct swsusp_extent *cur_ext;
    - unsigned long offset;
    -};
    -
    -static struct storage_position pos;
    -
    -static void reset_storage_pos(void)
    -{
    - pos.node = rb_first(&swsusp_extents);
    -
    - if (!pos.node) {
    - pos.cur_ext = NULL;
    - pos.offset = 0;
    - return;
    - }
    -
    - pos.cur_ext = container_of(pos.node, struct swsusp_extent, node);
    - pos.offset = pos.cur_ext->start;
    -}
    +static struct hib_extent_state swap_extents;

    static sector_t next_swapdev_block(void)
    {
    - if (!pos.node)
    - return 0;
    -
    - if (pos.cur_ext->end >= pos.offset)
    - return pos.offset++;
    -
    - pos.node = rb_next(pos.node);
    - if (!pos.node)
    - return 0;
    -
    - pos.cur_ext = container_of(pos.node, struct swsusp_extent, node);
    - pos.offset = pos.cur_ext->start;
    - return pos.offset;
    -}
    -
    -static int swsusp_extents_insert(unsigned long swap_offset)
    -{
    - struct rb_node **new = &(swsusp_extents.rb_node);
    - struct rb_node *parent = NULL;
    - struct swsusp_extent *ext;
    -
    - /* Figure out where to put the new node */
    - while (*new) {
    - ext = container_of(*new, struct swsusp_extent, node);
    - parent = *new;
    - if (swap_offset < ext->start) {
    - /* Try to merge */
    - if (swap_offset == ext->start - 1) {
    - ext->start--;
    - return 0;
    - }
    - new = &((*new)->rb_left);
    - } else if (swap_offset > ext->end) {
    - /* Try to merge */
    - if (swap_offset == ext->end + 1) {
    - ext->end++;
    - return 0;
    - }
    - new = &((*new)->rb_right);
    - } else {
    - /* It already is in the tree */
    - return -EINVAL;
    - }
    - }
    - /* Add the new node and rebalance the tree. */
    - ext = kzalloc(sizeof(struct swsusp_extent), GFP_KERNEL);
    - if (!ext)
    - return -ENOMEM;
    -
    - ext->start = swap_offset;
    - ext->end = swap_offset;
    - rb_link_node(&ext->node, parent, new);
    - rb_insert_color(&ext->node, &swsusp_extents);
    - return 0;
    + unsigned long res = hib_extent_next(&swap_extents);
    + if (res)
    + res = swapdev_block(root_swap, res);
    + return res;
    }

    /**
    @@ -179,7 +96,7 @@ sector_t alloc_swapdev_block(int swap)

    offset = swp_offset(get_swap_page_of_type(swap));
    if (offset) {
    - if (swsusp_extents_insert(offset))
    + if (hib_extents_insert(&swap_extents, offset))
    swap_free(swp_entry(swap, offset));
    else
    return swapdev_block(swap, offset);
    @@ -223,7 +140,7 @@ static int allocate_swap(unsigned int nr_pages)
    return 0;
    }

    - reset_storage_pos();
    + hib_reset_extent_pos(&swap_extents);
    return 1;
    }

    @@ -235,24 +152,18 @@ static int allocate_swap(unsigned int nr_pages)

    void free_all_swap_pages(int swap)
    {
    - struct rb_node *node;
    -
    - while ((node = swsusp_extents.rb_node)) {
    - struct swsusp_extent *ext;
    - unsigned long offset;
    + unsigned long offset;

    - ext = container_of(node, struct swsusp_extent, node);
    - rb_erase(node, &swsusp_extents);
    - for (offset = ext->start; offset <= ext->end; offset++)
    - swap_free(swp_entry(swap, offset));
    + hib_reset_extent_pos(&swap_extents);
    + while ((offset = hib_extent_next(&swap_extents)))
    + swap_free(swp_entry(swap, offset));

    - kfree(ext);
    - }
    + hib_extents_clear(&swap_extents);
    }

    int swsusp_swap_in_use(void)
    {
    - return (swsusp_extents.rb_node != NULL);
    + return (!hib_extents_empty(&swap_extents));
    }

    /*
    --
    1.7.0.4


    \
     
     \ /
      Last update: 2010-06-02 14:25    [W:0.034 / U:0.628 seconds]
    ©2003-2016 Jasper Spaans. hosted at Digital OceanAdvertise on this site