Commit 80f8dfde authored by Juan Quintela's avatar Juan Quintela
Browse files

migration: Make cache_init() take an error parameter 



Once there, take a total size instead of the size of the pages.  We
move the check that the new_size is bigger than one page from
xbzrle_cache_resize().

Signed-off-by: default avatarJuan Quintela <quintela@redhat.com>
Reviewed-by: default avatarPeter Xu <peterx@redhat.com>

--

Fix typo spotted by Peter Xu
parent 8acabf69

migration/page_cache.c

+11 −6
Original line number Diff line number Diff line
@@ -14,6 +14,8 @@ 


#include "qemu/osdep.h"



#include "qapi/qmp/qerror.h"

#include "qapi/error.h"

#include "qemu-common.h"

#include "qemu/host-utils.h"

#include "migration/page_cache.h"
@@ -44,21 +46,23 @@ struct PageCache { 
    size_t num_items;

};



PageCache *cache_init(size_t num_pages, size_t page_size)

PageCache *cache_init(int64_t new_size, size_t page_size, Error **errp)

{

    int64_t i;



    size_t num_pages = new_size / page_size;

    PageCache *cache;



    if (num_pages <= 0) {

        DPRINTF("invalid number of pages\n");

    if (new_size < page_size) {

        error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "cache size",

                   "is smaller than one target page size");

        return NULL;

    }



    /* We prefer not to abort if there is no memory */

    cache = g_try_malloc(sizeof(*cache));

    if (!cache) {

        DPRINTF("Failed to allocate cache\n");

        error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "cache size",

                   "Failed to allocate cache");

        return NULL;

    }

    /* round down to the nearest power of 2 */
@@ -76,7 +80,8 @@ PageCache *cache_init(size_t num_pages, size_t page_size) 
    cache->page_cache = g_try_malloc((cache->max_num_items) *

                                     sizeof(*cache->page_cache));

    if (!cache->page_cache) {

        DPRINTF("Failed to allocate cache->page_cache\n");

        error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "cache size",

                   "Failed to allocate page cache");

        g_free(cache);

        return NULL;

    }

migration/page_cache.h

+3 −4
Original line number Diff line number Diff line
@@ -24,12 +24,11 @@ typedef struct PageCache PageCache; 
 *

 * Returns new allocated cache or NULL on error

 *

 * @cache pointer to the PageCache struct

 * @num_pages: cache maximal number of cached pages

 * @cache_size: cache size in bytes

 * @page_size: cache page size

 * @errp: set *errp if the check failed, with reason

 */

PageCache *cache_init(size_t num_pages, size_t page_size);



PageCache *cache_init(int64_t cache_size, size_t page_size, Error **errp);

/**

 * cache_fini: free all cache resources

 * @cache pointer to the PageCache struct

migration/ram.c

+5 −13
Original line number Diff line number Diff line
@@ -135,22 +135,14 @@ int64_t xbzrle_cache_resize(int64_t new_size, Error **errp) 
        return -1;

    }



    if (new_size < TARGET_PAGE_SIZE) {

        error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "cache size",

                   "is smaller than one target page size");

        return -1;

    }



    XBZRLE_cache_lock();



    if (XBZRLE.cache != NULL) {

        if (pow2floor(new_size) == migrate_xbzrle_cache_size()) {

            goto out_new_size;

        }

        new_cache = cache_init(new_size / TARGET_PAGE_SIZE,

                                        TARGET_PAGE_SIZE);

        new_cache = cache_init(new_size, TARGET_PAGE_SIZE, errp);

        if (!new_cache) {

            error_setg(errp, "Error creating cache");

            ret = -1;

            goto out;

        }
@@ -2028,6 +2020,7 @@ err: 
static int ram_state_init(RAMState **rsp)

{

    *rsp = g_new0(RAMState, 1);

    Error *local_err = NULL;



    qemu_mutex_init(&(*rsp)->bitmap_mutex);

    qemu_mutex_init(&(*rsp)->src_page_req_mutex);
@@ -2036,12 +2029,11 @@ static int ram_state_init(RAMState **rsp) 
    if (migrate_use_xbzrle()) {

        XBZRLE_cache_lock();

        XBZRLE.zero_target_page = g_malloc0(TARGET_PAGE_SIZE);

        XBZRLE.cache = cache_init(migrate_xbzrle_cache_size() /

                                  TARGET_PAGE_SIZE,

                                  TARGET_PAGE_SIZE);

        XBZRLE.cache = cache_init(migrate_xbzrle_cache_size(),

                                  TARGET_PAGE_SIZE, &local_err);

        if (!XBZRLE.cache) {

            XBZRLE_cache_unlock();

            error_report("Error creating cache");

            error_report_err(local_err);

            g_free(*rsp);

            *rsp = NULL;

            return -1;